@abi-software/flatmap-viewer 2.7.2 → 2.7.3-a.2

package/src/pathways.js

@@ -1,427 +0,0 @@
-/******************************************************************************
-
-Flatmap viewer and annotation tool
-
-Copyright (c) 2020  David Brooks
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless 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.
-
-******************************************************************************/
-
-'use strict';
-
-import {colord} from 'colord'
-
-//==============================================================================
-
-import { reverseMap } from './utils';
-
-export const PATHWAYS_LAYER = 'pathways';
-
-//==============================================================================
-
-export const APINATOMY_PATH_PREFIX = 'ilxtr:';
-
-//==============================================================================
-
-const PATH_TYPES = [
-    { type: "cns", label: "CNS", colour: "#9B1FC1"},
-    { type: "intracardiac", label: "Local circuit neuron", colour: "#F19E38"},
-    { type: "para-pre", label: "Parasympathetic pre-ganglionic", colour: "#3F8F4A"},
-    { type: "para-post", label: "Parasympathetic post-ganglionic", colour: "#3F8F4A", dashed: true},
-    { type: "sensory", label: "Sensory (afferent) neuron", colour: "#2A62F6"},
-    { type: "motor", label: "Somatic lower motor", colour: "#98561D"},
-    { type: "somatic", label: "Somatic lower motor", colour: "#98561D"},
-    { type: "symp-pre", label: "Sympathetic pre-ganglionic", colour: "#EA3423"},
-    { type: "symp-post", label: "Sympathetic post-ganglionic", colour: "#EA3423", dashed: true},
-    { type: "other", label: "Other neuron type", colour: "#888"},
-    { type: "arterial", label: "Arterial blood vessel", colour: "#F00", enabled: false},
-    { type: "venous", label: "Venous blood vessel", colour: "#2F6EBA", enabled: false},
-    { type: "centreline", label: "Nerve centrelines", colour: "#CCC", enabled: false},
-    { type: "error", label: "Paths with errors or warnings", colour: "#FF0", enabled: false}
-];
-
-const PathTypeMap = new Map(PATH_TYPES.map(t => [t.type, t]))
-
-export const PATH_STYLE_RULES =
-    PATH_TYPES.flatMap(pathType => [['==', ['get', 'kind'], pathType.type], pathType.colour]);
-
-export function pathColourArray(pathType, alpha=255)
-//==================================================
-{
-    const rgb = colord(PathTypeMap.has(pathType)
-                        ? PathTypeMap.get(pathType).colour
-                        : PathTypeMap.get('other').colour).toRgb()
-    return [rgb.r, rgb.g, rgb.b, alpha]
-}
-
-//==============================================================================
-
-export class PathManager
-{
-    constructor(flatmap, ui, enabled=true)
-    {
-        this.__ui = ui;
-        this.__connectivityModelPaths = {};                          // modelId: [pathIds]
-        this.__pathToConnectivityModel = {};
-        if ('models' in flatmap.pathways) {
-            for (const model of flatmap.pathways.models) {
-                this.__connectivityModelPaths[model.id] = model.paths;
-                for (const path of model.paths) {
-                    this.__pathToConnectivityModel[path] = model.id;
-                }
-            }
-        }
-        this.__pathModelPaths = {};                             // pathModelId: [pathIds]
-        this.__pathToPathModel = {};                            // pathId: pathModelId
-        this.__paths = {};                                      // pathId: path
-        const pathLines = {};                                   // pathId: [lineIds]
-        const pathNerves = {};                                  // pathId: [nerveIds]
-        if ('paths' in flatmap.pathways) {
-            for (const [pathId, path] of Object.entries(flatmap.pathways.paths)) {
-                pathLines[pathId] = path.lines;
-                pathNerves[pathId] = path.nerves;
-                this.__paths[pathId] = path;
-                this.__paths[pathId].systemCount = 0;
-                if ('models' in path) {
-                    const modelId = path['models'];
-                    if (!(modelId in this.__pathModelPaths)) {
-                        this.__pathModelPaths[modelId] = [];
-                    }
-                    this.__pathModelPaths[modelId].push(pathId);
-                    this.__pathToPathModel[pathId] = modelId;
-                }
-            }
-        }
-        this.__pathsByLine = reverseMap(pathLines);               // lineId: [pathIds]
-        this.__pathsByNerve = reverseMap(pathNerves);             // nerveId: [pathIds]
-
-        const nodePaths = flatmap.pathways['node-paths'];
-        this._nodePaths = nodePaths;                                 // nodeId: [pathIds]
-        const featureIds = new Set();
-        for (const paths of Object.values(this._nodePaths)) {
-            this.addPathsToFeatureSet_(paths, featureIds);
-        }
-        this._allFeatureIds = featureIds;
-
-        // Construct a list of path types we know about
-        const pathTypes = {};
-        this.__pathtypeEnabled = {};
-        for (const pathTypeDefn of PATH_TYPES) {
-            pathTypes[pathTypeDefn.type] = pathTypeDefn;
-            this.__pathtypeEnabled[pathTypeDefn.type] = !('enabled' in pathTypeDefn) || pathTypeDefn.enabled;
-        }
-
-        // Set path types, mapping unknown path types to ``other``
-        this.__pathsByType = {};
-        this.__pathsByType['other'] = [];
-        for (const [pathType, paths] of Object.entries(flatmap.pathways['type-paths'])) {
-            if (pathType in pathTypes) {
-                this.__pathsByType[pathType] = paths;
-                const pathDefn = pathTypes[pathType];
-            } else {
-                this.__pathsByType['other'].push(...paths);
-                this.__pathtypeEnabled[pathType] = false;
-            }
-        }
-        // Assign types to individual paths
-        this.__assignPathTypes();
-
-        // Nerve centrelines are a special case with their own controls
-        this.__haveCentrelines = false;
-        this.__enabledCentrelines = false;
-    }
-
-    get haveCentrelines()
-    //===================
-    {
-        return this.__haveCentrelines;
-    }
-
-    get enabledCentrelines()
-    //======================
-    {
-        return this.__enabledCentrelines;
-    }
-
-    __assignPathTypes()
-    //=================
-    {
-        for (const [pathType, paths] of Object.entries(this.__pathsByType)) {
-            for (const pathId of paths) {
-                this.__paths[pathId].pathType = pathType;
-            }
-        }
-    }
-
-    pathStyles()
-    //==========
-    {
-        const styles = []
-        for (const mapType of this.pathTypes()) {
-            const defn = PathTypeMap.get(mapType.type)
-            styles.push({
-                type: defn.type,
-                colour: defn.colour,
-                dashed: defn.dashed || false
-            })
-        }
-        return styles
-    }
-
-    pathTypes()
-    //=========
-    {
-        const pathTypes = [];
-        for (const pathTypeDefn of PATH_TYPES) {
-            if (pathTypeDefn.type in this.__pathsByType
-            && this.__pathsByType[pathTypeDefn.type].length > 0) {
-                if (pathTypeDefn.type === 'centreline') {
-                    this.__haveCentrelines = true;
-                    this.__enabledCentrelines = this.__pathtypeEnabled[pathTypeDefn.type];
-                } else {
-                    pathTypes.push({
-                        ...pathTypeDefn,
-                        enabled: this.__pathtypeEnabled[pathTypeDefn.type]
-                    });
-                }
-            }
-        }
-        return pathTypes;
-    }
-
-    addPathsToFeatureSet_(pathIds, featureSet)
-    //======================================
-    {
-        for (const pathId of pathIds) {
-            const path = this.__paths[pathId];
-            path.lines.forEach(lineId => featureSet.add(lineId));
-            path.nerves.forEach(nerveId => featureSet.add(nerveId));
-            path.nodes.forEach(nodeId => featureSet.add(nodeId));
-        }
-    }
-
-    allFeatureIds()
-    //=============
-    {
-        return this._allFeatureIds;
-    }
-
-    lineFeatureIds(lineIds)
-    //=====================
-    {
-        const featureIds = new Set();
-        for (const lineId of lineIds) {
-            if (lineId in this.__pathsByLine) {
-                this.addPathsToFeatureSet_(this.__pathsByLine[lineId], featureIds);
-            }
-        }
-        return featureIds;
-    }
-
-    nerveFeatureIds(nerveId)
-    //======================
-    {
-        const featureIds = new Set();
-        if (nerveId in this.__pathsByNerve) {
-            this.addPathsToFeatureSet_(this.__pathsByNerve[nerveId], featureIds);
-        }
-        return featureIds;
-    }
-
-    pathProperties(feature)
-    //=====================
-    {
-        const properties = Object.assign({}, feature.properties);
-        if (feature.id in this.__pathsByLine) {
-            for (const pathId of this.__pathsByLine[feature.id]) {
-                // There should only be a single path for a line
-                if (pathId in this.__pathToConnectivityModel) {
-                    properties['connectivity'] = this.__pathToConnectivityModel[pathId];
-                }
-                if (pathId in this.__pathToPathModel) {
-                    properties['models'] = this.__pathToPathModel[pathId];
-                }
-            }
-/*
-            if (!('connectivity' in properties)) {
-                for (const pathId of this.__pathsByNerve[feature.id]) {
-                    if (pathId in this.__pathToConnectivityModel) {
-                        properties['connectivity'] = this.__pathToConnectivityModel[pathId];
-                        break;
-                    }
-                }
-            }
-*/
-        }
-        return properties;
-    }
-
-    connectivityModelFeatureIds(modelId)
-    //==================================
-    {
-        const featureIds = new Set();
-        if (modelId in this.__connectivityModelPaths) {
-            this.addPathsToFeatureSet_(this.__connectivityModelPaths[modelId], featureIds);
-            }
-        return featureIds;
-    }
-
-    pathModelFeatureIds(modelId)
-    //==========================
-    {
-        const featureIds = new Set();
-        if (modelId in this.__pathModelPaths) {
-            this.addPathsToFeatureSet_(this.__pathModelPaths[modelId], featureIds);
-            }
-        return featureIds;
-    }
-
-    isNode(id)
-    //========
-    {
-        return id in this._nodePaths;
-    }
-
-    pathFeatureIds(nodeId)
-    //====================
-    {
-        const featureIds = new Set();
-        if (nodeId in this._nodePaths) {
-            this.addPathsToFeatureSet_(this._nodePaths[nodeId], featureIds);
-        }
-        return featureIds;
-    }
-
-    __typeFeatureIds(pathType)
-    //========================
-    {
-        const featureIds = new Set();
-        if (pathType in this.__pathsByType) {
-            this.addPathsToFeatureSet_(this.__pathsByType[pathType], featureIds);
-        }
-        return featureIds;
-    }
-
-    enablePathLines(enable, force=false)
-    //==================================
-    {
-        for (const lineId of Object.keys(this.__pathsByLine)) {
-            this.__ui.enableFeature(lineId, enable, force)
-        }
-    }
-
-    enablePathsBySystem(system, enable, force=false)
-    //==============================================
-    {
-        let changed = false;
-        for (const pathId of system.pathIds) {
-            const path = this.__paths[pathId];
-            if (this.__pathtypeEnabled[path.pathType]
-              && (force
-               || enable && path.systemCount === 0
-               || !enable && path.systemCount == 1)) {
-                // and type(pathId) is enabled...
-                const featureIds = new Set();
-                this.addPathsToFeatureSet_([pathId], featureIds)
-                for (const featureId of featureIds) {
-                    this.__ui.enableFeature(featureId, enable, force);
-                }
-                changed = true
-            }
-            path.systemCount += (enable ? 1 : -1);
-            if (path.systemCount < 0) {
-                path.systemCount = 0;
-            }
-            // TODO? Show connectors and parent components of these paths??
-        }
-        if (changed) {
-            this.#notifyWatchers()
-        }
-    }
-
-    enablePathsByType(pathType, enable, force=false)
-    //==============================================
-    {
-        if (force
-         || enable && !this.__pathtypeEnabled[pathType]
-         || !enable && this.__pathtypeEnabled[pathType]) {
-            for (const featureId of this.__typeFeatureIds(pathType)) {
-                this.__ui.enableFeature(featureId, enable, force);
-            }
-            this.__pathtypeEnabled[pathType] = enable;
-            this.#notifyWatchers({pathType})
-        }
-    }
-
-    pathTypeEnabled(pathType)
-    //=======================
-    {
-        return this.__pathtypeEnabled[pathType] || false
-    }
-
-    nodePathModels(nodeId)
-    //====================
-    {
-        const modelIds = new Set();
-        if (nodeId in this._nodePaths) {
-            for (const pathId of this._nodePaths[nodeId]) {
-                if (pathId in this.__pathToPathModel) {
-                    modelIds.add(this.__pathToPathModel[pathId]);
-                }
-            }
-        }
-        return modelIds;
-    }
-
-    pathModelNodes(modelId)
-    //=====================
-    {
-        const nodeIds = new Set();
-        if (modelId in this.__pathModelPaths) {
-            for (const pathId of this.__pathModelPaths[modelId]) {
-                for (const nodeId of this.__paths[pathId].nodes) {
-                    nodeIds.add(nodeId);
-                }
-            }
-        }
-        return nodeIds;
-    }
-
-    #lastWatcherId = 0
-    #watcherCallbacks = new Map()
-
-    addWatcher(callback)
-    //==================
-    {
-        this.#lastWatcherId += 1
-        this.#watcherCallbacks.set(this.#lastWatcherId, callback)
-        return this.#lastWatcherId
-    }
-
-    removeWatcher(watcherId)
-    //======================
-    {
-        this.#watcherCallbacks.delete(watcherId)
-    }
-
-    #notifyWatchers(changes={})
-    //=========================
-    {
-        for (const callback of this.#watcherCallbacks.values()) {
-            callback(changes)
-        }
-    }
-}
-
-//==============================================================================

package/src/search.js

@@ -1,137 +0,0 @@
-/******************************************************************************
-
-Flatmap viewer and annotation tool
-
-Copyright (c) 2019  David Brooks
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless 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.
-
-******************************************************************************/
-
-'use strict';
-
-//==============================================================================
-
-import MiniSearch from 'minisearch';
-
-//==============================================================================
-
-// The properties of a feature we index and show
-
-export const indexedProperties = [
-    'label',
-    'models',
-    'source'
-];
-
-//==============================================================================
-
-export class SearchIndex
-{
-    constructor()
-    {
-        this._searchEngine =  new MiniSearch({
-            fields: ['text'],
-            storeFields: ['text'],
-            tokenize: (string, _fieldName) => string.split(' ')
-        });
-        this._featureIds = [];
-    }
-
-    indexMetadata(featureId, metadata)
-    //================================
-    {
-        const textSeen = [];
-        for (const prop of indexedProperties) {
-            if (prop in metadata) {
-                const text = metadata[prop];
-                if (!textSeen.includes(text)) {
-                    this.indexText(featureId, text);
-                    textSeen.push(text);
-                }
-            }
-        }
-    }
-
-    indexText(featureId, text)
-    //========================
-    {
-        text = text.replace(new RegExp('<br/>', 'g'), ' ')
-                   .replace(new RegExp('\n', 'g'), ' ')
-                   ;
-        if (text) {
-            this._searchEngine.add({
-                id: this._featureIds.length,
-                text: text
-            });
-            this._featureIds.push(featureId);
-        }
-    }
-
-    clearResults()
-    //============
-    {
-        this._;
-    }
-
-    auto_suggest(text)
-    //================
-    {
-        return this._searchEngine.autoSuggest(text, {prefix: true});
-    }
-
-    search(text)
-    //==========
-    {
-        const options = {};
-        let results = [];
-        text = text.trim()
-        if (text.length > 2 && ["'", '"'].includes(text.slice(0, 1))) {
-            text = text.replaceAll(text.slice(0, 1), '');
-            results = this._searchEngine.search(text, {prefix: true, combineWith: 'AND'});
-        } else if (text.length > 1) {
-            results = this._searchEngine.search(text, {prefix: true});
-        }
-        const featureResults = results.map(r => {
-            return {
-                featureId: this._featureIds[r.id],
-                score: r.score,
-                terms: r.terms,
-                text: r.text
-            }});
-        return new SearchResults(featureResults);
-    }
-}
-
-//==============================================================================
-
-class SearchResults
-{
-    constructor(results)
-    {
-        this.__results = results.sort((a, b) => (b.score - a.score));
-        this.__featureIds = results.map(r => r.featureId);
-    }
-
-    get featureIds()
-    {
-        return this.__featureIds;
-    }
-
-    get results()
-    {
-        return this.__results;
-    }
-}
-
-//==============================================================================

package/src/systems.js

@@ -1,146 +0,0 @@
-/******************************************************************************
-
-Flatmap viewer and annotation tool
-
-Copyright (c) 2019 - 2023  David Brooks
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless 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.
-
-******************************************************************************/
-
-const FC_KIND = {
-    SYSTEM: ['fc:System', 'fc-class:System'],
-    ORGAN:  ['fc:Organ', 'fc-class:Organ'],
-    FTU:    ['fc:Ftu', 'fc-class:Ftu']
-};
-
-//==============================================================================
-
-export class SystemsManager
-{
-    constructor(flatmap, ui, enabled=false)
-    {
-        this.__flatmap = flatmap;
-        this.__ui = ui;
-        this.__systems = new Map();
-        this.__enabledChildren = new Map();
-        for (const [_, ann] of flatmap.annotations) {
-            if (FC_KIND.SYSTEM.includes(ann['fc-class'])) {
-                const systemId = ann.name.replaceAll(' ', '_');
-                if (this.__systems.has(systemId)) {
-                    this.__systems.get(systemId).featureIds.push(ann.featureId)
-                } else {
-                    this.__systems.set(systemId, {
-                        name: ann.name,
-                        colour: ann.colour,
-                        featureIds: [ ann.featureId ],
-                        enabled: false,
-                        pathIds: ('path-ids' in ann) ? ann['path-ids'] : [],
-                        organs: this.__children(ann.children, FC_KIND.ORGAN)
-                    });
-                this.__ui.enableFeature(ann.featureId, false, true);
-                }
-                for (const childId of ann['children']) {
-                    this.__enabledChildren.set(childId, 0);
-                    this.__ui.enableFeatureWithChildren(childId, false, true);
-                }
-            }
-        }
-        for (const system of this.__systems.values()) {
-            if (enabled) {
-                this.__enableSystem(system, true);
-            } else {
-                // Disable all paths associated with the disabled system
-                this.__ui.enablePathsBySystem(system, false, true);
-            }
-        }
-    }
-
-    __children(childFeatureIds, childClass)
-    //=====================================
-    {
-        const children = [];
-        for (const childFeatureId of childFeatureIds || []) {
-            const childAnnotation = this.__flatmap.annotation(childFeatureId);
-            if (childAnnotation !== undefined && childClass.includes(childAnnotation['fc-class'])) {
-                const child = {
-                    label: childAnnotation.label,
-                    models: childAnnotation.models
-                };
-                if (childClass === FC_KIND.ORGAN) {
-                    child.ftus = this.__children(childAnnotation.children, FC_KIND.FTU)
-                };
-                children.push(child);
-            }
-        }
-        return children;
-    }
-
-    get systems()
-    //===========
-    {
-        const systems = [];
-        for (const [systemId, system] of this.__systems.entries()) {
-            systems.push({
-                id: systemId,
-                name: system.name,
-                colour: system.colour,
-                enabled: system.enabled,
-                organs: system.organs
-            });
-        }
-        return systems;
-    }
-
-    enable(systemId, enable=true)
-    //===========================
-    {
-        const system = this.__systems.get(systemId);
-        if (system !== undefined && enable !== system.enabled) {
-            this.__enableSystem(system, enable);
-        }
-    }
-
-    __enableSystem(system, enable=true)
-    //=================================
-    {
-        for (const featureId of system.featureIds) {
-            const feature = this.__ui.mapFeature(featureId);
-            if (feature !== undefined) {
-                this.__ui.enableMapFeature(feature, enable);
-                for (const childFeatureId of feature.children) {
-                    const enabledCount = this.__enabledChildren.get(childFeatureId);
-                    if (enable && enabledCount === 0 || !enable && enabledCount == 1) {
-                        this.__ui.enableFeatureWithChildren(childFeatureId, enable);
-                    }
-                    this.__enabledChildren.set(childFeatureId, enabledCount + (enable ? 1 : -1));
-                }
-            }
-        }
-
-        // Enable/disable all paths associated with the system
-        this.__ui.enablePathsBySystem(system, enable);
-
-        // Save system state
-        system.enabled = enable;
-    }
-
-    systemEnabled(systemId)
-    //=====================
-    {
-        const system = this.__systems.get(systemId);
-        return (system !== undefined && system.enabled);
-    }
-}
-
-//==============================================================================