siibra 1.0a14__py3-none-any.whl → 1.0.1a0__py3-none-any.whl

siibra/livequeries/allen.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,12 +19,12 @@ from .query import LiveQuery
 from ..core import space as _space, structure
 from ..features import anchor as _anchor
 from ..features.tabular.gene_expression import GeneExpressions
-from ..commons import logger, Species, MapType
-from ..locations import point, pointset
+from ..commons import logger, Species
+from ..locations import point, pointcloud
 from ..retrieval import HttpRequest
 from ..vocabularies import GENE_NAMES
 
-from typing import Iterable
+from typing import List
 from xml.etree import ElementTree
 import numpy as np
 import json
@@ -32,6 +32,24 @@ import json
 
 BASE_URL = "http://api.brain-map.org/api/v2/data"
 
+LOCATION_PRECISION_MM = 2.  # the assumed spatial precision of the probe locations in MNI space
+
+
+def is_allen_api_microarray_service_available():
+    import requests
+
+    # see https://community.brain-map.org/t/human-brain-atlas-api/2876
+    microarray_test_url = "http://api.brain-map.org/api/v2/data/query.json?criteria= service::human_microarray_expression[probes$eq1023146,1023147][donors$eq15496][structures$eq9148]"
+    try:
+        response = requests.get(microarray_test_url).json()
+    except requests.RequestException:
+        return False
+    return response["success"]
+
+
+class InvalidAllenAPIResponseException(Exception):
+    pass
+
 
 class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions):
     """
@@ -101,9 +119,6 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         """
         LiveQuery.__init__(self, **kwargs)
         gene = kwargs.get('gene')
-        self.maptype = kwargs.get("maptype", None)
-        if isinstance(self.maptype, str):
-            self.maptype = MapType[self.maptype.upper()]
 
         def parse_gene(spec):
             if isinstance(spec, str):
@@ -120,7 +135,14 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
 
         self.genes = parse_gene(gene)
 
-    def query(self, concept: structure.BrainStructure) -> Iterable[GeneExpressions]:
+    def query(self, concept: structure.BrainStructure) -> List[GeneExpressions]:
+        if not is_allen_api_microarray_service_available():
+            raise InvalidAllenAPIResponseException(
+                'The service "web API of the Allen Brain Atlas for the human microarray expression" '
+                'is not available at the moment, therefore siibra is not able to fetch '
+                'gene expression features. This is a known issue which we are investigating: '
+                'https://github.com/FZJ-INM1-BDA/siibra-python/issues/636.'
+            )
 
         mnispace = _space.Space.registry().get('mni152')
 
@@ -128,20 +150,21 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         # Record matched instances and their locations.
         measurements = []
         coordinates = []
-        points_inside = dict()
         for measurement in self:
-            pt = point.Point(measurement['mni_xyz'], space=mnispace)
-            if pt not in points_inside:  # cache redundant intersection tests
-                points_inside[pt] = pt in concept
-            if points_inside[pt]:
+            pt = point.Point(measurement['mni_xyz'], space=mnispace, sigma_mm=LOCATION_PRECISION_MM)
+            if pt in concept:
                 measurements.append(measurement)
                 coordinates.append(pt)
 
+        if len(coordinates) == 0:
+            logger.info(f"No probes found that lie within {concept}")
+            return []
+
         # Build the anatomical anchor and assignment to the query concept.
         # It will be attached to the returned feature, with the set of matched
         # MNI coordinates as anchor's location.
         anchor = _anchor.AnatomicalAnchor(
-            location=pointset.from_points(coordinates),
+            location=pointcloud.from_points(coordinates),
             species=self.species
         )
         explanation = f"MNI coordinates of tissue samples were filtered using {concept}"
@@ -153,7 +176,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         )]
         anchor._last_matched_concept = concept
 
-        yield GeneExpressions(
+        return [GeneExpressions(
             anchor=anchor,
             genes=[m['gene'] for m in measurements],
             levels=[m['expression_level'] for m in measurements],
@@ -167,7 +190,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
                 "probe_id": [m['probe_id'] for m in measurements],
                 "donor_name": [m['donor_name'] for m in measurements],
             }
-        )
+        )]
 
     def __iter__(self):
 
@@ -261,7 +284,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         url = AllenBrainAtlasQuery._QUERY["specimen"].format(specimen_id=specimen_id)
         response = HttpRequest(url).get()
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving specimen information: {}".format(url)
             )
         # we ask for 1 specimen, so list should have length 1
@@ -278,7 +301,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         return specimen
 
     @classmethod
-    def _retrieve_microarray(cls, donor_id: str, probe_ids: str) -> Iterable[GeneExpressions]:
+    def _retrieve_microarray(cls, donor_id: str, probe_ids: str):
         """
         Retrieve microarray data for several probes of a given donor, and
         compute the MRI position of the corresponding tissue block in the ICBM
@@ -292,9 +315,12 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         url = AllenBrainAtlasQuery._QUERY["microarray"].format(
             probe_ids=",".join([str(id) for id in probe_ids]), donor_id=donor_id
         )
-        response = HttpRequest(url, json.loads).get()
+        try:
+            response = HttpRequest(url, json.loads).get()
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Allen institute site produced an empty response - please try again later.\n{e}")
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving microarray data: {}".format(url)
             )
 

siibra/livequeries/bigbrain.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@ from . import query
 from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
 from ..features import anchor as _anchor
 from ..commons import logger
-from ..locations import point, pointset
+from ..locations import point, pointcloud
 from ..core import structure
 from ..retrieval import requests, cache
 from ..retrieval.datasets import GenericDataset
@@ -119,11 +119,11 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
 
     def query(self, concept: structure.BrainStructure, **kwargs) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
         loader = WagstylProfileLoader()
-        mesh_vertices = pointset.PointSet(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointSet with og indices as labels
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
         if matched is None:
             return []
-        assert isinstance(matched, pointset.PointSet)
+        assert isinstance(matched, pointcloud.PointCloud)
         indices = matched.labels
         assert indices is not None
         features = []
@@ -159,11 +159,11 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
     def query(self, concept: structure.BrainStructure, **kwargs) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
 
         loader = WagstylProfileLoader()
-        mesh_vertices = pointset.PointSet(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointSet with og indices as labels
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
         if matched is None:
             return []
-        assert isinstance(matched, pointset.PointSet)
+        assert isinstance(matched, pointcloud.PointCloud)
         indices = matched.labels
         assert indices is not None
         matched_profiles = loader._profiles[indices, :]
@@ -177,7 +177,7 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
         ]).reshape((-1, 200))
 
         anchor = _anchor.AnatomicalAnchor(
-            location=pointset.PointSet(loader._vertices[indices, :], space='bigbrain'),
+            location=pointcloud.PointCloud(loader._vertices[indices, :], space='bigbrain'),
             region=str(concept),
             species='Homo sapiens'
         )

siibra/livequeries/ebrains.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/livequeries/query.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -47,4 +47,3 @@ class LiveQuery(ABC):
     @abstractmethod
     def query(self, concept: AtlasConcept, **kwargs) -> List[Feature]:
         raise NotImplementedError(f"Dervied class {self.__class__} needs to implement query()")
-        pass

siibra/locations/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2023
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,7 @@
 
 from .location import Location
 from .point import Point
-from .pointset import PointSet, from_points
+from .pointcloud import PointCloud, from_points
 from .boundingbox import BoundingBox
 
 
@@ -36,11 +36,11 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
     Returns
     -------
     Location
-        - Point U Point = PointSet
-        - Point U PointSet = PointSet
-        - PointSet U PointSet = PointSet
+        - Point U Point = PointCloud
+        - Point U PointCloud = PointCloud
+        - PointCloud U PointCloud = PointCloud
         - BoundingBox U BoundingBox = BoundingBox
-        - BoundingBox U PointSet = BoundingBox
+        - BoundingBox U PointCloud = BoundingBox
         - BoundingBox U Point = BoundingBox
         - WholeBrain U Location = NotImplementedError
         (all operations are commutative)
@@ -53,14 +53,14 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
     # location that has its own union method since it is not a part of locations
     # module and to avoid importing Volume here.
     if not all(
-        isinstance(loc, (Point, PointSet, BoundingBox)) for loc in [loc0, loc1]
+        isinstance(loc, (Point, PointCloud, BoundingBox)) for loc in [loc0, loc1]
     ):
         try:
             return loc1.union(loc0)
         except Exception:
             raise NotImplementedError(f"There are no union method for {(loc0.__class__.__name__, loc1.__class__.__name__)}")
 
-    # convert Points to PointSets
+    # convert Points to PointClouds
     loc0, loc1 = [
         from_points([loc]) if isinstance(loc, Point) else loc
         for loc in [loc0, loc1]
@@ -69,8 +69,8 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
     # adopt the space of the first location
     loc1_w = loc1.warp(loc0.space)
 
-    if isinstance(loc0, PointSet):
-        if isinstance(loc1_w, PointSet):
+    if isinstance(loc0, PointCloud):
+        if isinstance(loc1_w, PointCloud):
             points = list(dict.fromkeys([*loc0, *loc1_w]))
             return from_points(points)
         if isinstance(loc1_w, BoundingBox):

siibra/locations/boundingbox.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2023
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,11 +14,12 @@
 # limitations under the License.
 """A box defined by two farthest corner coordinates on a specific space."""
 
-from . import point, pointset, location
+from . import point, pointcloud, location
 
 from ..commons import logger
 from ..exceptions import SpaceWarpingFailedError
 
+from itertools import product
 import hashlib
 import numpy as np
 from typing import TYPE_CHECKING, Union
@@ -75,6 +76,7 @@ class BoundingBox(location.Location):
             s1, s2 = sigma_mm
         else:
             raise ValueError(f"Cannot interpret sigma_mm parameter value {sigma_mm} for bounding box")
+        self.sigma_mm = [s1, s2]
         self.minpoint = point.Point([min(xyz1[i], xyz2[i]) for i in range(3)], space, sigma_mm=s1)
         self.maxpoint = point.Point([max(xyz1[i], xyz2[i]) for i in range(3)], space, sigma_mm=s2)
         if minsize is not None:
@@ -82,6 +84,9 @@ class BoundingBox(location.Location):
                 if self.shape[d] < minsize:
                     self.maxpoint[d] = self.minpoint[d] + minsize
 
+        if self.volume == 0:
+            logger.warning(f"Zero-volume bounding box from points {point1} and {point2} in {self.space} space.")
+
     @property
     def id(self) -> str:
         return hashlib.md5(str(self).encode("utf-8")).hexdigest()
@@ -110,12 +115,12 @@ class BoundingBox(location.Location):
     def __str__(self):
         if self.space is None:
             return (
-                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)}) mm "
-                f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)}) mm"
+                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)})mm "
+                f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)})mm"
             )
         else:
             return (
-                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)}) mm "
+                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)})mm "
                 f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)})mm in {self.space.name} space"
             )
 
@@ -139,16 +144,16 @@ class BoundingBox(location.Location):
         if isinstance(other, point.Point):
             warped = other.warp(self.space)
             return other if self.minpoint <= warped <= self.maxpoint else None
-        if isinstance(other, pointset.PointSet):
+        if isinstance(other, pointcloud.PointCloud):
             points_inside = [p for p in other if self.intersects(p)]
-            result = pointset.PointSet(
+            if len(points_inside) == 0:
+                return None
+            result = pointcloud.PointCloud(
                 points_inside,
                 space=other.space,
                 sigma_mm=[p.sigma for p in points_inside]
             )
-            if len(result) == 0:
-                return None
-            return result[0] if len(result) == 1 else result  # if PointSet has single point return as a Point
+            return result[0] if len(result) == 1 else result  # if PointCloud has single point return as a Point
 
         return other.intersection(self)
 
@@ -183,12 +188,18 @@ class BoundingBox(location.Location):
                 result_minpt.append(A[dim])
                 result_maxpt.append(B[dim])
 
+        if result_minpt == result_maxpt:
+            return result_minpt
+
         bbox = BoundingBox(
             point1=point.Point(result_minpt, self.space),
             point2=point.Point(result_maxpt, self.space),
             space=self.space,
         )
-        return bbox if bbox.volume > 0 else None
+
+        if bbox.volume == 0 and sum(cmin == cmax for cmin, cmax in zip(result_minpt, result_maxpt)) == 2:
+            return None
+        return bbox
 
     def _intersect_mask(self, mask: 'Nifti1Image', threshold=0):
         """Intersect this bounding box with an image mask. Returns None if they do not intersect.
@@ -229,8 +240,8 @@ class BoundingBox(location.Location):
             )
         else:
             return self._intersect_bbox(
-                pointset
-                .PointSet(XYZ, space=self.space, sigma_mm=voxel_size.max())
+                pointcloud
+                .PointCloud(XYZ, space=self.space, sigma_mm=voxel_size.max())
                 .boundingbox
             )
 
@@ -245,6 +256,35 @@ class BoundingBox(location.Location):
             sigma_mm=[self.minpoint.sigma, self.maxpoint.sigma]
         )
 
+    @property
+    def corners(self):
+        """
+        Returns all 8 corners of the box as a pointcloud.
+
+        Note
+        ----
+        x0, y0, z0 = self.minpoint
+        x1, y1, z1 = self.maxpoint
+        all_corners = [
+            (x0, y0, z0),
+            (x1, y0, z0),
+            (x0, y1, z0),
+            (x1, y1, z0),
+            (x0, y0, z1),
+            (x1, y0, z1),
+            (x0, y1, z1),
+            (x1, y1, z1)
+        ]
+
+        TODO: deal with sigma. Currently, returns the mean of min and max point.
+        """
+        xs, ys, zs = zip(self.minpoint, self.maxpoint)
+        return pointcloud.PointCloud(
+            coordinates=[[x, y, z] for x, y, z in product(xs, ys, zs)],
+            space=self.space,
+            sigma_mm=np.mean([self.minpoint.sigma, self.maxpoint.sigma])
+        )
+
     def warp(self, space):
         """Returns a new bounding box obtained by warping the
         min- and maxpoint of this one into the new target space.
@@ -257,13 +297,10 @@ class BoundingBox(location.Location):
             return self
         else:
             try:
-                return self.__class__(
-                    point1=self.minpoint.warp(spaceobj),
-                    point2=self.maxpoint.warp(spaceobj),
-                    space=spaceobj,
-                )
-            except ValueError:
+                warped_corners = self.corners.warp(spaceobj)
+            except SpaceWarpingFailedError:
                 raise SpaceWarpingFailedError(f"Warping {str(self)} to {spaceobj.name} not successful.")
+            return warped_corners.boundingbox
 
     def transform(self, affine: np.ndarray, space=None):
         """Returns a new bounding box obtained by transforming the
@@ -282,12 +319,9 @@ class BoundingBox(location.Location):
         """
         from ..core.space import Space
         spaceobj = Space.get_instance(space)
-        return self.__class__(
-            point1=self.minpoint.transform(affine, spaceobj),
-            point2=self.maxpoint.transform(affine, spaceobj),
-            space=space,
-            sigma_mm=[self.minpoint.sigma, self.maxpoint.sigma]  # TODO: error propagation
-        )
+        result = self.corners.transform(affine, spaceobj).boundingbox
+        result.sigma_mm = [self.minpoint.sigma, self.maxpoint.sigma]  # TODO: error propagation
+        return result
 
     def shift(self, offset):
         return self.__class__(
@@ -326,7 +360,7 @@ class BoundingBox(location.Location):
         x1, y1, z1 = self.maxpoint
 
         # set of 8 corner points in source space
-        corners1 = pointset.PointSet(
+        corners1 = pointcloud.PointCloud(
             [
                 (x0, y0, z0),
                 (x0, y0, z1),
@@ -383,14 +417,15 @@ class BoundingBox(location.Location):
         return super().__hash__()
 
 
-def _determine_bounds(array: np.ndarray, threshold=0):
+def _determine_bounds(masked_array: np.ndarray, background: float = 0.0):
     """
-    Bounding box of nonzero values in a 3D array.
+    Bounding box of nonzero (background) values in a 3D array.
+
     https://stackoverflow.com/questions/31400769/bounding-box-of-numpy-array
     """
-    x = np.any(array > threshold, axis=(1, 2))
-    y = np.any(array > threshold, axis=(0, 2))
-    z = np.any(array > threshold, axis=(0, 1))
+    x = np.any(masked_array != background, axis=(1, 2))
+    y = np.any(masked_array != background, axis=(0, 2))
+    z = np.any(masked_array != background, axis=(0, 1))
     nzx, nzy, nzz = [np.where(v) for v in (x, y, z)]
     if any(len(nz[0]) == 0 for nz in [nzx, nzy, nzz]):
         # empty array
@@ -401,15 +436,19 @@ def _determine_bounds(array: np.ndarray, threshold=0):
     return np.array([[xmin, xmax + 1], [ymin, ymax + 1], [zmin, zmax + 1], [1, 1]])
 
 
-def from_array(array: np.ndarray, threshold=0, space: "Space" = None) -> "BoundingBox":
+def from_array(
+    array: np.ndarray,
+    background: Union[int, float] = 0.0,
+    space: "Space" = None
+) -> BoundingBox:
     """
-    Find the bounding box of an array.
+    Find the bounding box of non-background values for any 3D array.
 
     Parameters
     ----------
-    array : np.ndarray
-    threshold : int, default: 0
-    space : Space, default: None
+    array: np.ndarray
+    background: int or float, default: 0.0
+    space: Space, default: None
     """
-    bounds = _determine_bounds(array, threshold)
-    return BoundingBox(bounds[:3, 0], bounds[:3, 1], space=space)
+    bounds = _determine_bounds(array, background)
+    return BoundingBox(point1=bounds[:3, 0], point2=bounds[:3, 1], space=space)

siibra/locations/location.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2023
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,6 +21,10 @@ from ..core.structure import BrainStructure
 import numpy as np
 from abc import abstractmethod
 
+from typing import TYPE_CHECKING, Union, Dict
+if TYPE_CHECKING:
+    from siibra.core.space import Space
+
 
 class Location(BrainStructure):
     """
@@ -42,15 +46,19 @@ class Location(BrainStructure):
     _MASK_MEMO = {}  # cache region masks for Location._assign_region()
     _ASSIGNMENT_CACHE = {}  # caches assignment results, see Region.assign()
 
-    def __init__(self, space):
-        self._space_spec = space
+    def __init__(self, spacespec: Union[str, Dict[str, str], "Space"]):
+        self._space_spec = spacespec
         self._space_cached = None
 
     @property
     def space(self):
         if self._space_cached is None:
             from ..core.space import Space
-            self._space_cached = Space.get_instance(self._space_spec)
+            if isinstance(self._space_spec, dict):
+                spec = self._space_spec.get("@id") or self._space_spec.get("name")
+                self._space_cached = Space.get_instance(spec)
+            else:
+                self._space_cached = Space.get_instance(self._space_spec)
         return self._space_cached
 
     @abstractmethod

siibra/locations/point.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,10 +14,11 @@
 # limitations under the License.
 """Singular coordinate defined on a space, possibly with an uncertainty."""
 
-from . import location, boundingbox, pointset
+from . import location, boundingbox, pointcloud
 
 from ..commons import logger
 from ..retrieval.requests import HttpRequest
+from ..exceptions import SpaceWarpingFailedError, NoneCoordinateSuppliedError
 
 from urllib.parse import quote
 import re
@@ -55,10 +56,14 @@ class Point(location.Location):
             if len(digits) == 3:
                 return tuple(float(d) for d in digits)
         elif isinstance(spec, (tuple, list)) and len(spec) in [3, 4]:
+            if any(v is None for v in spec):
+                raise NoneCoordinateSuppliedError("Cannot parse cooridantes containing None values.")
             if len(spec) == 4:
                 assert spec[3] == 1
             return tuple(float(v.item()) if isinstance(v, np.ndarray) else float(v) for v in spec[:3])
         elif isinstance(spec, np.ndarray) and spec.size == 3:
+            if any(np.isnan(v) for v in spec):
+                raise NoneCoordinateSuppliedError("Cannot parse cooridantes containing NaN values.")
             return tuple(float(v.item()) if isinstance(v, np.ndarray) else float(v) for v in spec[:3])
         elif isinstance(spec, Point):
             return spec.coordinate
@@ -110,7 +115,7 @@ class Point(location.Location):
     def intersection(self, other: location.Location) -> "Point":
         if isinstance(other, Point):
             return self if self == other else None
-        elif isinstance(other, pointset.PointSet):
+        elif isinstance(other, pointcloud.PointCloud):
             return self if self in other else None
         else:
             return self if other.intersection(self) else None
@@ -125,7 +130,7 @@ class Point(location.Location):
         if spaceobj == self.space:
             return self
         if any(_ not in location.Location.SPACEWARP_IDS for _ in [self.space.id, spaceobj.id]):
-            raise ValueError(
+            raise SpaceWarpingFailedError(
                 f"Cannot convert coordinates between {self.space.id} and {spaceobj.id}"
             )
         url = "{server}/transform-point?source_space={src}&target_space={tgt}&x={x}&y={y}&z={z}".format(
@@ -137,9 +142,9 @@ class Point(location.Location):
             z=self.coordinate[2],
         )
         response = HttpRequest(url, lambda b: json.loads(b.decode())).get()
-        if any(map(np.isnan, response['target_point'])):
-            logger.debug(f'Warping {str(self)} to {spaceobj.name} resulted in NaN')
-            return None
+        if np.any(np.isnan(response['target_point'])):
+            raise SpaceWarpingFailedError(f'Warping {str(self)} to {spaceobj.name} resulted in NaN')
+
         return self.__class__(
             coordinatespec=tuple(response["target_point"]),
             space=spaceobj.id,
@@ -185,8 +190,8 @@ class Point(location.Location):
         return super().__hash__()
 
     def __eq__(self, other: 'Point'):
-        if isinstance(other, pointset.PointSet):
-            return other == self  # implemented at pointset
+        if isinstance(other, pointcloud.PointCloud):
+            return other == self  # implemented at pointcloud
         if not isinstance(other, Point):
             return False
         o = other if self.space is None else other.warp(self.space)