TypeScript factory.registerDataSourceFactory函数代码示例

}

export function getMeshSource(chunkManager: ChunkManager, url: string, lod: number) {
  const [baseUrls, path] = parseSpecialUrl(url);
  return getShardedMeshSource(chunkManager, {baseUrls, path, lod});
}

let existingVolumes = new Map<string, Promise<MultiscaleVolumeChunkSource>>();
export function getShardedVolume(baseUrls: string[], path: string) {
  let fullKey = stableStringify({'baseUrls': baseUrls, 'path': path});
  let existingResult = existingVolumes.get(fullKey);
  if (existingResult !== undefined) {
    return existingResult;
  }
  let promise = sendHttpRequest(openShardedHttpRequest(baseUrls, path + '/info'), 'json')
                    .then(response => new MultiscaleVolumeChunkSource(baseUrls, path, response));
  existingVolumes.set(fullKey, promise);
  return promise;
}

export function getVolume(url: string) {
  const [baseUrls, path] = parseSpecialUrl(url);
  return getShardedVolume(baseUrls, path);
}

registerDataSourceFactory('precomputed', {
  description: 'Precomputed file-backed data source',
  getVolume: getVolume,
  getMeshSource: getMeshSource,
});

          mat4.create(), info.qoffset, info.quatern, kOneVec, info.qfac),
      volumeSourceOptions,
    });
    return [[VolumeChunkSource.get(this.chunkManager, spec, {url: this.url})]];
  }

  getMeshSource(): null {
    return null;
  }
}

const VolumeChunkSource = defineParameterizedVolumeChunkSource(VolumeSourceParameters);

function getNiftiVolumeInfo(chunkManager: ChunkManager, url: string, cancellationToken: CancellationToken) {
  return chunkManager.rpc!.promiseInvoke<NiftiVolumeInfo>(
      GET_NIFTI_VOLUME_INFO_RPC_ID, {'chunkManager': chunkManager.addCounterpartRef(), 'url': url},
      cancellationToken);
}

export function getVolume(chunkManager: ChunkManager, url: string) {
  return chunkManager.memoize.getUncounted(
      {type: 'nifti/getVolume', url},
      () => getNiftiVolumeInfo(chunkManager, url, uncancelableToken)
                .then(info => new MultiscaleVolumeChunkSource(chunkManager, url, info)));
}

registerDataSourceFactory('nifti', {
  description: 'Single NIfTI file',
  getVolume: getVolume,
});

};

let existingVolumes = new Map<string, Promise<MultiscaleVolumeChunkSource>>();
export function getShardedVolume(baseUrls: string[], key: string) {
  let cacheKey = stableStringify({'baseUrls': baseUrls, 'key': key});
  let existingResult = existingVolumes.get(key);
  if (existingResult !== undefined) {
    return existingResult;
  }
  let promise =
      sendHttpRequest(openShardedHttpRequest(baseUrls, `/neuroglancer/info/${key}`), 'json')
          .then(response => new MultiscaleVolumeChunkSource(baseUrls, key, response));
  existingVolumes.set(cacheKey, promise);
  return promise;
}

const urlPattern = /^((?:http|https):\/\/[^\/?]+)\/(.*)$/;

export function getVolume(path: string) {
  let match = path.match(urlPattern);
  if (match === null) {
    throw new Error(`Invalid python volume path: ${JSON.stringify(path)}`);
  }
  return getShardedVolume([match[1]], match[2]);
}

registerDataSourceFactory('python', {
  description: 'Python-served volume',
  getVolume: getVolume,
});

 * 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.
 */

/**
 * Convenience interface for accessing openconnecto.me server.
 */

import {ChunkManager} from 'neuroglancer/chunk_manager/frontend';
import {registerDataSourceFactory} from 'neuroglancer/datasource/factory';
import {getShardedVolume, tokenAndChannelCompleter} from 'neuroglancer/datasource/ndstore/frontend';
import {LEGACY_URL_PREFIX} from 'neuroglancer/datasource/ndstore/base';

const HOSTNAMES = ['http://openconnecto.me', 'http://www.openconnecto.me'];

export function getVolume(chunkManager: ChunkManager, path: string) {
  return getShardedVolume(chunkManager, HOSTNAMES, path, LEGACY_URL_PREFIX);
}

export function volumeCompleter(url: string, chunkManager: ChunkManager) {
  return tokenAndChannelCompleter(chunkManager, HOSTNAMES, url, LEGACY_URL_PREFIX);
}

registerDataSourceFactory('openconnectome', {
  description: 'NDstore server hosted at openconnecto.me',
  getVolume,
  volumeCompleter,
});

        completions =
            getPrefixMatchesWithDescriptions(channelMatch[2], channelNames, x => x, x => {
              let channelObject = channelsObject[x];
              return `${channelObject['channel_type']} (${channelObject['datatype']})`;

            });
      }
    }
    return {offset: channelMatch[1].length + 1, completions};
  });
}

export function volumeCompleter(url: string): CancellablePromise<CompletionResult> {
  let match = url.match(urlPattern);
  if (match === null) {
    // We don't yet have a full hostname.
    return Promise.reject<CompletionResult>(null);
  }
  let hostnames = [match[1]];
  let path = match[2];
  return cancellableThen(
      tokenAndChannelCompleter(hostnames, path),
      completions => applyCompletionOffset(match[1].length + 1, completions));
}

registerDataSourceFactory('ndstore', {
  description: 'NDstore',
  volumeCompleter: volumeCompleter,
  getVolume: getVolume,
});

    if (projectInfo === undefined) {
      return Promise.reject<CompletionResult>(null);
    }
    let completions =
        getPrefixMatchesWithDescriptions(stackMatch[3], projectInfo.stacks, x => x[0], x => {
          return `${x[1].project}`;
        });
    return {offset: stackMatch[1].length + stackMatch[2].length + 2, completions};
  });
}

export function volumeCompleter(
    url: string, chunkManager: ChunkManager): Promise<CompletionResult> {
  let match = url.match(urlPattern);
  if (match === null) {
    // We don't yet have a full hostname.
    return Promise.reject<CompletionResult>(null);
  }
  let hostnames: string[] = match[1].split(',');
  let path = match[2];

  return stackAndProjectCompleter(chunkManager, hostnames, path)
      .then(completions => applyCompletionOffset(match![1].length + 1, completions));
}

registerDataSourceFactory('render', {
  description: 'Render',
  volumeCompleter: volumeCompleter,
  getVolume: getVolume,
});