Feat/na 123

README.md

@@ -155,7 +155,19 @@ node.js is required to build the viewer.
 
    `npm test -- --pattern='src/neuroglancer/util/uint64*'`
 
-6. See [package.json](package.json) for other commands available.
+6. To run python scripts for the local server:
+
+   Run
+
+   `npm run build-python`
+
+    `pip install .`
+
+    from the neuroglancer folder.
+    Now python scripts can run for the local server.
+
+
+7. See [package.json](package.json) for other commands available.
 
 # Creating a dependent project
 

python/neuroglancer/__init__.py

@@ -49,6 +49,7 @@
     BlendTool,  # noqa: F401
     OpacityTool,  # noqa: F401
     VolumeRenderingDepthSamplesTool,  # noqa: F401
+    VolumeRenderingModeTool,  # noqa: F401
     CrossSectionRenderScaleTool,  # noqa: F401
     SelectedAlphaTool,  # noqa: F401
     NotSelectedAlphaTool,  # noqa: F401

python/neuroglancer/viewer_state.py

@@ -170,6 +170,12 @@ class VolumeRenderingDepthSamplesTool(Tool):
     TOOL_TYPE = "volumeRenderingDepthSamples"
 
 
+@export_tool
+class VolumeRenderingModeTool(Tool):
+    __slots__ = ()
+    TOOL_TYPE = "volumeRenderingMode"
+
+
 @export_tool
 class CrossSectionRenderScaleTool(Tool):
     __slots__ = ()
@@ -549,6 +555,9 @@ def __init__(self, *args, **kwargs):
     cross_section_render_scale = crossSectionRenderScale = wrapped_property(
         "crossSectionRenderScale", optional(float, 1)
     )
+    volume_rendering_mode = volumeRenderingMode = wrapped_property(
+        "volumeRenderingMode", optional(str)
+    )
 
     @staticmethod
     def interpolate(a, b, t):

src/neuroglancer/image_user_layer.ts

@@ -27,13 +27,13 @@ import {MultiscaleVolumeChunkSource} from 'neuroglancer/sliceview/volume/fronten
 import {defineImageLayerShader, getTrackableFragmentMain, ImageRenderLayer} from 'neuroglancer/sliceview/volume/image_renderlayer';
 import {trackableAlphaValue} from 'neuroglancer/trackable_alpha';
 import {trackableBlendModeValue} from 'neuroglancer/trackable_blend';
-import {TrackableBoolean} from 'neuroglancer/trackable_boolean';
 import {makeCachedDerivedWatchableValue, makeCachedLazyDerivedWatchableValue, registerNested, WatchableValue, WatchableValueInterface} from 'neuroglancer/trackable_value';
 import {UserLayerWithAnnotationsMixin} from 'neuroglancer/ui/annotations';
 import {setClipboard} from 'neuroglancer/util/clipboard';
 import {Borrowed} from 'neuroglancer/util/disposable';
 import {makeValueOrError} from 'neuroglancer/util/error';
 import {verifyOptionalObjectProperty} from 'neuroglancer/util/json';
+import {trackableShaderModeValue, VOLUME_RENDERING_MODES} from 'neuroglancer/volume_rendering/trackable_volume_rendering_mode';
 import {getVolumeRenderingDepthSamplesBoundsLogScale, VOLUME_RENDERING_DEPTH_SAMPLES_DEFAULT_VALUE, VolumeRenderingRenderLayer} from 'neuroglancer/volume_rendering/volume_render_layer';
 import {makeWatchableShaderError, ParameterizedShaderGetterResult} from 'neuroglancer/webgl/dynamic_shader';
 import {setControlsInShader, ShaderControlsBuilderState, ShaderControlState} from 'neuroglancer/webgl/shader_ui_controls';
@@ -42,7 +42,6 @@ import {makeCopyButton} from 'neuroglancer/widget/copy_button';
 import {DependentViewContext} from 'neuroglancer/widget/dependent_view_widget';
 import {makeHelpButton} from 'neuroglancer/widget/help_button';
 import {addLayerControlToOptionsTab, LayerControlDefinition, registerLayerControl} from 'neuroglancer/widget/layer_control';
-import {checkboxLayerControl} from 'neuroglancer/widget/layer_control_checkbox';
 import {enumLayerControl} from 'neuroglancer/widget/layer_control_enum';
 import {rangeLayerControl} from 'neuroglancer/widget/layer_control_range';
 import {makeMaximizeButton} from 'neuroglancer/widget/maximize_button';
@@ -57,8 +56,8 @@ const SHADER_JSON_KEY = 'shader';
 const SHADER_CONTROLS_JSON_KEY = 'shaderControls';
 const CROSS_SECTION_RENDER_SCALE_JSON_KEY = 'crossSectionRenderScale';
 const CHANNEL_DIMENSIONS_JSON_KEY = 'channelDimensions';
-const VOLUME_RENDERING_JSON_KEY = 'volumeRendering';
 const VOLUME_RENDERING_DEPTH_SAMPLES_JSON_KEY = 'volumeRenderingDepthSamples';
+const VOLUME_RENDERING_MODE_JSON_KEY = 'volumeRenderingMode';
 
 export interface ImageLayerSelectionState extends UserLayerSelectionState {
   value: any;
@@ -87,7 +86,7 @@ export class ImageUserLayer extends Base {
   channelSpace = this.registerDisposer(makeCachedLazyDerivedWatchableValue(
       channelCoordinateSpace => makeValueOrError(() => getChannelSpace(channelCoordinateSpace)),
       this.channelCoordinateSpace));
-  volumeRendering = new TrackableBoolean(false, false);
+  volumeRenderingMode = trackableShaderModeValue();
 
   shaderControlState = this.registerDisposer(new ShaderControlState(
       this.fragmentMain,
@@ -127,9 +126,10 @@ export class ImageUserLayer extends Base {
     this.opacity.changed.add(this.specificationChanged.dispatch);
     this.fragmentMain.changed.add(this.specificationChanged.dispatch);
     this.shaderControlState.changed.add(this.specificationChanged.dispatch);
+    this.shaderControlState.changed.add(() => {console.log("shaderControlState changed");});
     this.sliceViewRenderScaleTarget.changed.add(this.specificationChanged.dispatch);
-    this.volumeRendering.changed.add(this.specificationChanged.dispatch);
     this.volumeRenderingDepthSamplesTarget.changed.add(this.specificationChanged.dispatch);
+    this.volumeRenderingMode.changed.add(this.specificationChanged.dispatch);
     this.tabs.add(
         'rendering',
         {label: 'Rendering', order: -100, getter: () => new RenderingOptionsTab(this)});
@@ -173,12 +173,13 @@ export class ImageUserLayer extends Base {
           chunkResolutionHistogram: this.volumeRenderingChunkResolutionHistogram,
           localPosition: this.localPosition,
           channelCoordinateSpace: this.channelCoordinateSpace,
+          mode: this.volumeRenderingMode,
         }));
         context.registerDisposer(loadedSubsource.messages.addChild(volumeRenderLayer.messages));
-        context.registerDisposer(registerNested((context, volumeRendering) => {
-          if (!volumeRendering) return;
+        context.registerDisposer(registerNested((context, volumeRenderingMode) => {
+          if (volumeRenderingMode === VOLUME_RENDERING_MODES.OFF) return;
           context.registerDisposer(this.addRenderLayer(volumeRenderLayer.addRef()));
-        }, this.volumeRendering));
+        }, this.volumeRenderingMode));
         this.shaderError.changed.dispatch();
       });
     }
@@ -195,9 +196,11 @@ export class ImageUserLayer extends Base {
     this.sliceViewRenderScaleTarget.restoreState(
         specification[CROSS_SECTION_RENDER_SCALE_JSON_KEY]);
     this.channelCoordinateSpace.restoreState(specification[CHANNEL_DIMENSIONS_JSON_KEY]);
-    this.volumeRendering.restoreState(specification[VOLUME_RENDERING_JSON_KEY]);
     this.volumeRenderingDepthSamplesTarget.restoreState(
         specification[VOLUME_RENDERING_DEPTH_SAMPLES_JSON_KEY]);
+    verifyOptionalObjectProperty(
+        specification, VOLUME_RENDERING_MODE_JSON_KEY,
+        mode => this.volumeRenderingMode.restoreState(mode));
   }
   toJSON() {
     const x = super.toJSON();
@@ -207,8 +210,8 @@ export class ImageUserLayer extends Base {
     x[SHADER_CONTROLS_JSON_KEY] = this.shaderControlState.toJSON();
     x[CROSS_SECTION_RENDER_SCALE_JSON_KEY] = this.sliceViewRenderScaleTarget.toJSON();
     x[CHANNEL_DIMENSIONS_JSON_KEY] = this.channelCoordinateSpace.toJSON();
-    x[VOLUME_RENDERING_JSON_KEY] = this.volumeRendering.toJSON();
     x[VOLUME_RENDERING_DEPTH_SAMPLES_JSON_KEY] = this.volumeRenderingDepthSamplesTarget.toJSON();
+    x[VOLUME_RENDERING_MODE_JSON_KEY] = this.volumeRenderingMode.toJSON();
     return x;
   }
 
@@ -318,20 +321,22 @@ const LAYER_CONTROLS: LayerControlDefinition<ImageUserLayer>[] = [
   },
   {
     label: 'Volume rendering (experimental)',
-    toolJson: VOLUME_RENDERING_JSON_KEY,
-    ...checkboxLayerControl(layer => layer.volumeRendering),
+    toolJson: VOLUME_RENDERING_MODE_JSON_KEY,
+    ...enumLayerControl(layer => layer.volumeRenderingMode),
   },
   {
     label: 'Resolution (3D)',
     toolJson: VOLUME_RENDERING_DEPTH_SAMPLES_JSON_KEY,
-    isValid: layer => layer.volumeRendering,
+    isValid: layer => makeCachedDerivedWatchableValue(
+        volumeRendering => (volumeRendering !== VOLUME_RENDERING_MODES.OFF),
+        [layer.volumeRenderingMode]),
     ...renderScaleLayerControl(
         layer => ({
           histogram: layer.volumeRenderingChunkResolutionHistogram,
           target: layer.volumeRenderingDepthSamplesTarget
         }),
         VolumeRenderingRenderScaleWidget,
-        )
+        ),
   },
 ];
 

src/neuroglancer/layer.ts

@@ -59,6 +59,8 @@ const SOURCE_JSON_KEY = 'source';
 const TRANSFORM_JSON_KEY = 'transform';
 const PICK_JSON_KEY = 'pick';
 
+const METACELL_TAG = ' 011223'
+
 export interface UserLayerSelectionState {
   generation: number;
 
@@ -269,7 +271,7 @@ export class UserLayer extends RefCounted {
     this.dataSourcesChanged.add(() => this.updateDataSubsourceActivations());
     this.messages.changed.add(this.layersChanged.dispatch);
     this.tabs.add('source', {
-      label: 'Source',
+      label: `Source ${METACELL_TAG}`,
       order: -100,
       getter: () => new LayerDataSourcesTab(this),
     });

src/neuroglancer/sliceview/volume/image_renderlayer.ts

@@ -26,8 +26,14 @@ import {ShaderBuilder, ShaderProgram} from 'neuroglancer/webgl/shader';
 import {addControlsToBuilder, getFallbackBuilderState, parseShaderUiControls, setControlsInShader, ShaderControlsBuilderState, ShaderControlState} from 'neuroglancer/webgl/shader_ui_controls';
 
 const DEFAULT_FRAGMENT_MAIN = `#uicontrol invlerp normalized
+#uicontrol transferFunction colormap
 void main() {
-  emitGrayscale(normalized());
+  if (!VOLUME_RENDERING) {
+    emitGrayscale(normalized());
+  }
+  else {
+    emitRGBA(colormap());
+  }
 }
 `;
 
@@ -46,6 +52,8 @@ export function defineImageLayerShader(
     builder: ShaderBuilder, shaderBuilderState: ShaderControlsBuilderState) {
   builder.addFragmentCode(`
 #define VOLUME_RENDERING false
+#define MAX_PROJECTION false
+float maxIntensity = 0.0;
 
 void emitRGBA(vec4 rgba) {
   emit(vec4(rgba.rgb, rgba.a * uOpacity));

src/neuroglancer/volume_rendering/trackable_volume_rendering_mode.ts

@@ -0,0 +1,13 @@
+import {TrackableEnum} from 'neuroglancer/util/trackable_enum';
+
+export enum VOLUME_RENDERING_MODES {
+  OFF = 0,
+  ON = 1,
+  MAX = 2
+}
+
+export type TrackableVolumeRenderingModeValue = TrackableEnum<VOLUME_RENDERING_MODES>;
+
+export function trackableShaderModeValue(initialValue = VOLUME_RENDERING_MODES.OFF) {
+  return new TrackableEnum(VOLUME_RENDERING_MODES, initialValue);
+}