torch-reconstruct-tomogram 0.6.0__py3-none-any.whl

torch_reconstruct_tomogram/__init__.py

@@ -0,0 +1,26 @@
+"""(sub-)tomogram reconstruction and subtilt extraction for cryoET."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("torch-reconstruct-tomogram")
+except PackageNotFoundError:
+    __version__ = "uninstalled"
+__author__ = "Marten Chaillet, Davide Torre"
+__email__ = "martenchaillet@gmail.com, davidetorre99@gmail.com"
+
+from torch_reconstruct_tomogram.projection import (
+    extract_particle_tilt_series,
+    project_points,
+)
+from torch_reconstruct_tomogram.reconstruct import (
+    reconstruct_subvolume,
+    reconstruct_tomogram,
+)
+
+__all__ = [
+    "extract_particle_tilt_series",
+    "project_points",
+    "reconstruct_subvolume",
+    "reconstruct_tomogram",
+]

torch_reconstruct_tomogram/projection.py

@@ -0,0 +1,77 @@
+"""Project 3D points into tilt images and crop patches for reconstruction."""
+
+from typing import Any
+
+import torch
+from torch_grid_utils import dft_center
+from torch_subpixel_crop import subpixel_crop_2d
+from torch_tilt_series import (
+    TiltSeries,
+    load_tilt_series_images,
+    preprocess_tilt_series_images,
+)
+
+
+def project_points(tilt_series: TiltSeries, points_zyx: torch.Tensor) -> torch.Tensor:
+    """Project 3D points to 2D image pixel coordinates.
+
+    - points are 3D zyx coordinates in Angstroms, relative to the tomogram center
+    - tilt_series supplies the projection geometry (`tilt_series.project_points`
+      works in Angstroms) and `tilt_series.pixel_spacing` (raises if unset),
+      used to convert the projected Angstrom positions to pixels
+    - projected 2D points are in pixels, relative to the center of each image
+    """
+    return tilt_series.project_points(points_zyx) / tilt_series.pixel_spacing
+
+
+def _extract_particle_tilt_series(
+    tilt_series: TiltSeries,
+    images: torch.Tensor,
+    points_zyx: torch.Tensor,
+    sidelength: int,
+    return_rfft: bool = True,
+) -> torch.Tensor:
+    """Extract a subtilt-series given already-loaded images."""
+    projected_yx = project_points(tilt_series, points_zyx)
+    projected_yx = projected_yx + dft_center(
+        images.shape[-2:], rfft=False, fftshift=True, device=images.device
+    )
+    return subpixel_crop_2d(
+        image=images,
+        positions=projected_yx,
+        sidelength=sidelength,
+        return_rfft=return_rfft,
+        decenter=return_rfft,
+    )
+
+
+def extract_particle_tilt_series(
+    tilt_series: TiltSeries,
+    points_zyx: torch.Tensor,
+    sidelength: int,
+    return_rfft: bool = True,
+    preprocess: bool = True,
+    **preprocessing_kwargs: Any,
+) -> torch.Tensor:
+    """Extract a subtilt-series at 3D location(s) in the sample.
+
+    Loads (and, by default, preprocesses) the raw tilt images matching
+    `tilt_series` via `tilt_series.image_path`/`image_indices`. Preprocessing
+    (see `torch_tilt_series.preprocess_tilt_series_images`) by default applies
+    plane subtraction, a DC-excluding bandpass with no low-pass (i.e. up to
+    Nyquist), and central-crop normalization. `**preprocessing_kwargs` are
+    forwarded to `preprocess_tilt_series_images`, overriding any of its
+    defaults (`low`, `high`, `falloff`, `bandpass_padding`,
+    `subtract_background`, `normalize`) - see that function's docstring for
+    details.
+    """
+    images = load_tilt_series_images(tilt_series)
+    if preprocess:
+        images = preprocess_tilt_series_images(images, **preprocessing_kwargs)
+    return _extract_particle_tilt_series(
+        tilt_series,
+        images,
+        points_zyx,
+        sidelength,
+        return_rfft=return_rfft,
+    )

torch_reconstruct_tomogram/py.typed

@@ -0,0 +1,5 @@
+You may remove this file if you don't intend to add types to your package
+
+Details at:
+
+https://mypy.readthedocs.io/en/stable/installed_packages.html#creating-pep-561-compatible-packages

torch_reconstruct_tomogram/reconstruct.py

@@ -0,0 +1,294 @@
+"""(sub-)tomogram reconstruction in pytorch."""
+
+from typing import Any
+
+import einops
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch_fourier_rescale import fourier_rescale_rfft_2d
+from torch_fourier_slice import insert_central_slices_rfft_3d_multichannel
+from torch_grid_utils import fftfreq_grid
+from torch_tilt_series import (
+    TiltSeries,
+    load_tilt_series_images,
+    preprocess_tilt_series_images,
+)
+
+from torch_reconstruct_tomogram.projection import _extract_particle_tilt_series
+
+_PAD_FACTOR = 2.0
+
+
+def _writable(data):
+    if isinstance(data, np.ndarray) and not data.flags.writeable:
+        data = data.copy()
+    return data
+
+
+def _reconstruct_subvolume(
+    tilt_series: TiltSeries,
+    images: torch.Tensor,
+    points_zyx: torch.Tensor,
+    sidelength: int,
+    output_pixel_spacing: float | None = None,
+) -> torch.Tensor:
+    """Reconstruct subvolume(s), given already-loaded images."""
+    device = images.device
+    input_pixel_spacing = tilt_series.pixel_spacing  # raises if unset
+    if output_pixel_spacing is None:
+        output_pixel_spacing = input_pixel_spacing
+
+    points_zyx = torch.as_tensor(_writable(points_zyx), device=device).float()
+    points_zyx, ps = einops.pack([points_zyx], "* zyx")
+
+    # tomogram -> detector rotation: projection_matrices is sample -> detector
+    # only, so compose tomo2sample's rotation in first. Every patch's
+    # Fourier-insertion rotation must be expressed relative to the
+    # tomogram frame.
+    rotation_matrices = (
+        tilt_series.projection_matrices[:, :3, :3] @ tilt_series.tomo2sample[:3, :3]
+    )
+    rotation_matrices = torch.linalg.pinv(rotation_matrices)
+
+    sidelength_padded_output = int(_PAD_FACTOR * sidelength)
+    sidelength_padded_native = max(
+        1,
+        round(sidelength_padded_output * output_pixel_spacing / input_pixel_spacing),
+    )
+
+    particle_tilt_series_rfft = _extract_particle_tilt_series(
+        tilt_series,
+        images,
+        points_zyx,
+        sidelength=sidelength_padded_native,
+        return_rfft=True,
+    )
+
+    particle_tilt_series_rfft = torch.fft.fftshift(particle_tilt_series_rfft, dim=(-2,))
+
+    particle_tilt_series_rfft = fourier_rescale_rfft_2d(
+        dft=particle_tilt_series_rfft,
+        image_shape=(sidelength_padded_native, sidelength_padded_native),
+        target_shape=(sidelength_padded_output, sidelength_padded_output),
+    )
+
+    particle_tilt_series_rfft = einops.rearrange(
+        particle_tilt_series_rfft,
+        "n_positions n_tilts h w_rfft -> n_tilts n_positions h w_rfft",
+    )
+
+    patches_rfft, weights = insert_central_slices_rfft_3d_multichannel(
+        image_rfft=particle_tilt_series_rfft,
+        volume_shape=(sidelength_padded_output,) * 3,
+        rotation_matrices=rotation_matrices,
+        zyx_matrices=True,
+        fftfreq_max=0.5,
+    )
+
+    valid_weights = weights > 1e-3
+    patches_rfft[:, valid_weights] /= weights[valid_weights]
+
+    patches_rfft = torch.fft.ifftshift(patches_rfft, dim=(-3, -2))
+
+    patches = torch.fft.irfftn(
+        patches_rfft,
+        s=(sidelength_padded_output,) * 3,
+        dim=(-3, -2, -1),
+    )
+
+    patches = torch.fft.ifftshift(patches, dim=(-3, -2, -1))
+
+    grid = fftfreq_grid(
+        image_shape=(sidelength_padded_output,) * 3,
+        rfft=False,
+        fftshift=True,
+        norm=True,
+        device=device,
+    )
+    patches = patches / torch.sinc(grid) ** 2
+
+    p = (sidelength_padded_output - sidelength) // 2
+    patches = F.pad(patches, [-p] * 6)
+
+    [patches] = einops.unpack(patches, ps, "* d h w")
+
+    return patches
+
+
+def reconstruct_subvolume(
+    tilt_series: TiltSeries,
+    points_zyx: torch.Tensor,
+    sidelength: int,
+    output_pixel_spacing: float | None = None,
+    preprocess: bool = True,
+    **preprocessing_kwargs: Any,
+) -> torch.Tensor:
+    """Reconstruct 3D patch(es) at location(s) in the sample.
+
+    Rank-polymorphic: input (..., 3) -> output (..., d, h, w)
+
+    - tilt_series supplies the projection geometry,
+    - points_zyx are zyx coordinates in Angstroms, relative to the tomogram center
+    - sidelength is the output subvolume size in voxels
+    - output_pixel_spacing is the voxel size of the output in Angstroms
+      (defaults to `tilt_series.pixel_spacing`); the per-tilt 2D crops are
+      Fourier-rescaled to this pixel size before 3D reconstruction, so local
+      (subvolume) and global (tomogram) reconstructions can each target an
+      arbitrary output pixel size independent of the raw data's
+    - preprocess, if True (default), applies
+      `torch_tilt_series.preprocess_tilt_series_images` to the loaded images
+      before reconstruction - by default plane subtraction, a DC-excluding
+      bandpass with no low-pass, i.e. up to Nyquist, and central-crop
+      normalization
+    - `**preprocessing_kwargs` are forwarded to `preprocess_tilt_series_images`,
+      overriding any of its defaults (`low`, `high`, `falloff`,
+      `bandpass_padding`, `subtract_background`, `normalize`) - see that
+      function's docstring for details
+    """
+    images = load_tilt_series_images(tilt_series)
+    if preprocess:
+        images = preprocess_tilt_series_images(images, **preprocessing_kwargs)
+    return _reconstruct_subvolume(
+        tilt_series,
+        images,
+        points_zyx,
+        sidelength,
+        output_pixel_spacing=output_pixel_spacing,
+    )
+
+
+def _cosine_taper_window(core_length: int, margin: int, device) -> torch.Tensor:
+    """1D cosine-taper window, flat in the middle, tapered at the edges.
+
+    1.0 over the central `core_length` samples, cosine-tapered from 0 up to 1
+    (and back down to 0) over `margin` samples on each side. Total length is
+    core_length + 2 * margin.
+    """
+    if margin == 0:
+        return torch.ones(core_length, device=device)
+    ramp = 0.5 * (1 - torch.cos(torch.linspace(0, torch.pi, margin, device=device)))
+    core = torch.ones(core_length, device=device)
+    return torch.cat([ramp, core, ramp.flip(0)])
+
+
+def reconstruct_tomogram(
+    tilt_series: TiltSeries,
+    volume_shape: tuple[int, int, int],
+    sidelength: int,
+    batch_size: int | None = None,
+    output_pixel_spacing: float | None = None,
+    preprocess: bool = True,
+    blend_margin: int | None = None,
+    **preprocessing_kwargs: Any,
+) -> torch.Tensor:
+    """Reconstruct the full tomogram by tiling reconstructed patches in 3D.
+
+    - tilt_series supplies the projection geometry, plus `image_path`/
+      `image_indices` used to load the raw images
+    - volume_shape is the (d, h, w) shape of the output tomogram, in voxels
+    - sidelength is the spacing between patch centers, in voxels; patches
+      are reconstructed on a grid tiling `volume_shape`
+    - batch_size, if set, reconstructs at most this many patches per chunk
+      (to bound memory usage); defaults to reconstructing all patches at once
+    - output_pixel_spacing is the voxel size of the output in Angstroms
+      (defaults to `tilt_series.pixel_spacing`)
+    - preprocess, if True (default), applies
+      `torch_tilt_series.preprocess_tilt_series_images` to the loaded images
+      before reconstruction - by default plane subtraction, a DC-excluding
+      bandpass with no low-pass, i.e. up to Nyquist, and central-crop
+      normalization
+    - blend_margin is the extra margin, in voxels, added around each patch
+      (total reconstructed patch size is `sidelength + 2 * blend_margin`);
+      overlapping patches are cosine-tapered and blended together over this
+      margin to avoid seams at patch boundaries. Defaults to
+      `sidelength // 4`
+    - `**preprocessing_kwargs` are forwarded to `preprocess_tilt_series_images`,
+      overriding any of its defaults (`low`, `high`, `falloff`,
+      `bandpass_padding`, `subtract_background`, `normalize`) - see that
+      function's docstring for details
+    """
+    images = load_tilt_series_images(tilt_series)
+    if preprocess:
+        images = preprocess_tilt_series_images(images, **preprocessing_kwargs)
+
+    pixel_spacing = tilt_series.pixel_spacing  # raises if unset
+    if output_pixel_spacing is None:
+        output_pixel_spacing = pixel_spacing
+
+    if blend_margin is None:
+        blend_margin = sidelength // 4
+    patch_sidelength = sidelength + 2 * blend_margin
+    half = patch_sidelength // 2
+
+    d, h, w = volume_shape
+    r = sidelength // 2
+    device = images.device
+
+    z_centers = torch.arange(start=r, end=d + r, step=sidelength, device=device)
+    y_centers = torch.arange(start=r, end=h + r, step=sidelength, device=device)
+    x_centers = torch.arange(start=r, end=w + r, step=sidelength, device=device)
+    # absolute 0-indexed voxel coordinates of each patch center
+    centers_voxel = torch.stack(
+        torch.meshgrid(z_centers, y_centers, x_centers, indexing="ij"), dim=-1
+    )
+
+    volume_center = torch.tensor([d, h, w], device=device) // 2
+    centers_zyx_ang = (centers_voxel - volume_center) * output_pixel_spacing
+
+    window_1d = _cosine_taper_window(sidelength, blend_margin, device="cpu")
+    window_3d = (
+        window_1d[:, None, None] * window_1d[None, :, None] * window_1d[None, None, :]
+    )
+
+    tomogram_sum = torch.zeros(volume_shape, dtype=torch.float32)
+    weight_sum = torch.zeros(volume_shape, dtype=torch.float32)
+
+    centers_flat, _ = einops.pack([centers_voxel], "* zyx")
+    centers_ang_flat, _ = einops.pack([centers_zyx_ang], "* zyx")
+    chunk_size = batch_size or len(centers_flat)
+
+    for start in range(0, len(centers_flat), chunk_size):
+        chunk_centers = centers_flat[start : start + chunk_size]
+        chunk_centers_ang = centers_ang_flat[start : start + chunk_size]
+
+        patches_batch = _reconstruct_subvolume(
+            tilt_series,
+            images,
+            chunk_centers_ang,
+            patch_sidelength,
+            output_pixel_spacing=output_pixel_spacing,
+        ).cpu()
+
+        for j in range(len(patches_batch)):
+            cz, cy, cx = chunk_centers[j].tolist()
+            z0, y0, x0 = cz - half, cy - half, cx - half
+            z1, y1, x1 = (
+                z0 + patch_sidelength,
+                y0 + patch_sidelength,
+                x0 + patch_sidelength,
+            )
+
+            # clip the patch's placement to the volume bounds
+            cz0, cy0, cx0 = max(z0, 0), max(y0, 0), max(x0, 0)
+            cz1, cy1, cx1 = min(z1, d), min(y1, h), min(x1, w)
+            if cz0 >= cz1 or cy0 >= cy1 or cx0 >= cx1:
+                continue
+
+            src = (
+                slice(cz0 - z0, cz1 - z0),
+                slice(cy0 - y0, cy1 - y0),
+                slice(cx0 - x0, cx1 - x0),
+            )
+            dst = (slice(cz0, cz1), slice(cy0, cy1), slice(cx0, cx1))
+            weight_block = window_3d[src]
+            tomogram_sum[dst] += patches_batch[j][src] * weight_block
+            weight_sum[dst] += weight_block
+
+        del patches_batch
+        if device.type != "cpu":
+            torch.cuda.empty_cache()
+
+    tomogram = tomogram_sum / weight_sum.clamp_min(1e-6)
+
+    return tomogram.to(device)

torch_reconstruct_tomogram-0.6.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: torch-reconstruct-tomogram
+Version: 0.6.0
+Summary: (sub-)tomogram reconstruction and subtilt extraction for cryoET.
+Project-URL: homepage, https://github.com/teamtomo/teamtomo
+Project-URL: repository, https://github.com/teamtomo/teamtomo
+Project-URL: documentation, https://github.com/teamtomo/teamtomo#readme
+Project-URL: changelog, https://github.com/teamtomo/teamtomo#changelog
+Project-URL: Bug Tracker, https://github.com/teamtomo/teamtomo/issues
+Project-URL: Source Code, https://github.com/teamtomo/teamtomo
+Author-email: Marten Chaillet <martenchaillet@gmail.com>, Davide Torre <davidetorre99@gmail.com>
+License: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: einops
+Requires-Dist: torch
+Requires-Dist: torch-ctf
+Requires-Dist: torch-fourier-rescale
+Requires-Dist: torch-fourier-slice
+Requires-Dist: torch-grid-utils>=0.0.8
+Requires-Dist: torch-subpixel-crop
+Requires-Dist: torch-tilt-series[io]
+Description-Content-Type: text/markdown
+
+# torch-reconstruct-tomogram
+
+[![License](https://img.shields.io/pypi/l/torch-reconstruct-tomogram.svg?color=green)](https://github.com/teamtomo/torch-reconstruct-tomogram/raw/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/torch-reconstruct-tomogram.svg?color=green)](https://pypi.org/project/torch-reconstruct-tomogram)
+[![Python Version](https://img.shields.io/pypi/pyversions/torch-reconstruct-tomogram.svg?color=green)](https://python.org)
+[![CI](https://github.com/teamtomo/torch-reconstruct-tomogram/actions/workflows/ci.yml/badge.svg)](https://github.com/teamtomo/torch-reconstruct-tomogram/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/teamtomo/torch-reconstruct-tomogram/branch/main/graph/badge.svg)](https://codecov.io/gh/teamtomo/torch-reconstruct-tomogram)
+
+(sub-)Tomogram reconstruction and subtilt extraction for cryo-ET.
+
+## Overview
+
+This package provides (sub-)tomogram reconstruction and subtilt extraction driven entirely from a [`torch-tilt-series`](https://github.com/teamtomo/torch-tilt-series) `TiltSeries`. It supports
+
+* `extract_particle_tilt_series()`: extract a subtilt-series at 3D location(s) in the sample
+* `reconstruct_subvolume()`: rank-polymorphic reconstruction of 3D patch(es) at location(s) in the sample
+* `reconstruct_tomogram()`: full volume reconstruction by tiling reconstructed patches in 3D
+
+`TiltSeries` holds alignment geometry (in Angstroms) plus `image_path`/`image_indices`/`pixel_spacing` metadata. The functions above take a `TiltSeries`, and load and (by default) preprocess the matching raw images internally via `torch_tilt_series.load_tilt_series_images()` / `preprocess_tilt_series_images()` (by default: plane subtraction, a DC-excluding bandpass with no low-pass, i.e. up to Nyquist, and central-crop normalization); pass `**preprocessing_kwargs` to override any of its defaults (`low=`, `high=`, `falloff=`, `bandpass_padding=`, `subtract_background=`, `normalize=`) - see `preprocess_tilt_series_images()`'s docstring for details.  `output_pixel_spacing` lets both local (`reconstruct_subvolume`) and global (`reconstruct_tomogram`) reconstruction target an arbitrary output voxel size. Reconstruction happens at the input pixel spacing and is Fourier-rescaled to the requested output size. Reconstruction is performed in Fourier space using central slice insertion. Positions are in `zyx` coordinates, in Angstroms, relative to the tomogram center.
+
+## Installation
+
+```bash
+pip install torch-reconstruct-tomogram
+```
+
+To load a tilt series from AreTomo or ETOMO output, also install the IO dependencies for [`torch-tilt-series`](https://github.com/teamtomo/torch-tilt-series):
+
+```bash
+pip install torch-tilt-series[io]
+```
+
+## Examples
+
+See the [`examples/`](examples/) folder for scripts showing how to load a tilt series, reconstruct subvolumes and tomograms, and save the result.
+
+## License
+
+This project is licensed under the BSD 3-Clause License - see the LICENSE file for details.

torch_reconstruct_tomogram-0.6.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+torch_reconstruct_tomogram/__init__.py,sha256=Yfx6btqTSN0UbDn5EZy3BvHNrbq0iSaop5ajsk2pG2Q,712
+torch_reconstruct_tomogram/projection.py,sha256=okn6eJOeYYSHtdbjCz0IBlpuvUuDoIr5Ea_fXMDOQfY,2766
+torch_reconstruct_tomogram/py.typed,sha256=esB4cHc6c07uVkGtqf8at7ttEnprwRxwk8obY8Qumq4,187
+torch_reconstruct_tomogram/reconstruct.py,sha256=urTrH1_9EJjtgFpgDeXKjAIGPSeLO0cPdBgdHIs2EvA,11026
+torch_reconstruct_tomogram-0.6.0.dist-info/METADATA,sha256=RVUq4yqffdZ4F_fk4ZnKwmDBbe04IrNisHRRSeTq_kc,4346
+torch_reconstruct_tomogram-0.6.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+torch_reconstruct_tomogram-0.6.0.dist-info/licenses/LICENSE,sha256=VGqEjX52frBcv7zRe_8L0JTYMQ2EFvZpH2QNcDgYDZw,1515
+torch_reconstruct_tomogram-0.6.0.dist-info/RECORD,,

torch_reconstruct_tomogram-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

torch_reconstruct_tomogram-0.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, TeamTomo
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.