polytope-python 1.0.31__py3-none-any.whl

polytope_feature/datacube/tensor_index_tree.py

@@ -0,0 +1,228 @@
+import logging
+from typing import OrderedDict
+
+from sortedcontainers import SortedList
+
+from .datacube_axis import IntDatacubeAxis, UnsliceableDatacubeAxis
+
+
+class DatacubePath(OrderedDict):
+    def values(self):
+        return tuple(super().values())
+
+    def keys(self):
+        return tuple(super().keys())
+
+    def pprint(self):
+        result = ""
+        for k, v in self.items():
+            result += f"{k}={v},"
+        print(result[:-1])
+
+
+class TensorIndexTree(object):
+    root = IntDatacubeAxis()
+    root.name = "root"
+
+    def __init__(self, axis=root, values=tuple()):
+        # NOTE: the values here is a tuple so we can hash it
+        self.values = values
+        self.children = SortedList()
+        self._parent = None
+        self.result = []
+        self.axis = axis
+        self.ancestors = []
+        self.indexes = []
+        self.hidden = False
+
+    @property
+    def leaves(self):
+        leaves = []
+        self._collect_leaf_nodes(leaves)
+        return leaves
+
+    def _collect_leaf_nodes(self, leaves):
+        if len(self.children) == 0:
+            leaves.append(self)
+            self.ancestors.append(self)
+        for n in self.children:
+            for ancestor in self.ancestors:
+                n.ancestors.append(ancestor)
+            if self.axis != TensorIndexTree.root:
+                n.ancestors.append(self)
+            n._collect_leaf_nodes(leaves)
+
+    def __setitem__(self, key, value):
+        setattr(self, key, value)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __delitem__(self, key):
+        return delattr(self, key)
+
+    def __hash__(self):
+        return hash((self.axis.name, self.values))
+
+    def __eq__(self, other):
+        if not isinstance(other, TensorIndexTree):
+            return False
+        if self.axis.name != other.axis.name:
+            return False
+        else:
+            if other.values == self.values:
+                return True
+            else:
+                if isinstance(self.axis, UnsliceableDatacubeAxis):
+                    return False
+                else:
+                    if len(other.values) != len(self.values):
+                        return False
+                    for i in range(len(other.values)):
+                        other_val = other.values[i]
+                        self_val = self.values[i]
+                        if self.axis.can_round:
+                            if abs(other_val - self_val) > 2 * max(other.axis.tol, self.axis.tol):
+                                return False
+                        else:
+                            if other_val != self_val:
+                                return False
+                    return True
+
+    def __lt__(self, other):
+        return (self.axis.name, self.values) < (other.axis.name, other.values)
+
+    def __repr__(self):
+        if self.axis != "root":
+            return f"{self.axis.name}={self.values}"
+        else:
+            return f"{self.axis}"
+
+    def add_child(self, node):
+        self.children.add(node)
+        node._parent = self
+
+    def add_value(self, value):
+        new_values = list(self.values)
+        new_values.append(value)
+        new_values.sort()
+        self.values = tuple(new_values)
+
+    def create_child(self, axis, value, next_nodes):
+        node = TensorIndexTree(axis, (value,))
+        existing_child = self.find_child(node)
+        if not existing_child:
+            self.add_child(node)
+            return (node, next_nodes)
+        return (existing_child, next_nodes)
+
+    @property
+    def parent(self):
+        return self._parent
+
+    @parent.setter
+    def set_parent(self, node):
+        if self.parent is not None:
+            self.parent.children.remove(self)
+        self._parent = node
+        self._parent.children.add(self)
+
+    def get_root(self):
+        node = self
+        while node.parent is not None:
+            node = node.parent
+        return node
+
+    def is_root(self):
+        return self.parent is None
+
+    def find_child(self, node):
+        index = self.children.bisect_left(node)
+        if index >= len(self.children):
+            return None
+        child = self.children[index]
+        if not child == node:
+            return None
+        return child
+
+    def add_node_layer_after(self, ax_name, vals):
+        ax = IntDatacubeAxis()
+        ax.name = ax_name
+        interm_node = TensorIndexTree(ax, vals)
+        interm_node.children = self.children
+        interm_node._parent = self
+        self.children = SortedList()
+        self.children.add(interm_node)
+        return interm_node
+
+    def delete_non_index_nodes(self, index_vals):
+        grandparent = self._parent._parent
+        grandparent.indexes.extend(index_vals)
+        self.remove_branch()
+        return grandparent
+
+    def hide_non_index_nodes(self, index_vals):
+        grandparent = self._parent._parent
+        grandparent.indexes.extend(index_vals)
+        self.hide_two_levels()
+        return grandparent
+
+    def hide_two_levels(self):
+        self.hidden = True
+        if self._parent.non_hidden_children() == 0:
+            self._parent.hidden = True
+
+    def non_hidden_children(self):
+        non_hidden_child_counter = 0
+        for c in self.children:
+            if not c.hidden:
+                non_hidden_child_counter += 1
+        return non_hidden_child_counter
+
+    def merge(self, other):
+        for other_child in other.children:
+            my_child = self.find_child(other_child)
+            if not my_child:
+                self.add_child(other_child)
+            else:
+                my_child.merge(other_child)
+
+    def pprint(self, level=0):
+        if self.axis.name == "root":
+            logging.debug("\n")
+        logging.debug("\t" * level + "\u21b3" + str(self))
+        for child in self.children:
+            if not child.hidden:
+                child.pprint(level + 1)
+        if len(self.children) == 0:
+            logging.debug("\t" * (level + 1) + "\u21b3" + str(self.result))
+
+    def remove_branch(self):
+        if not self.is_root():
+            old_parent = self._parent
+            self._parent.children.remove(self)
+            self._parent = None
+            if len(old_parent.children) == 0:
+                old_parent.remove_branch()
+
+    def remove_compressed_branch(self, value):
+        if value in self.values:
+            if len(self.values) == 1:
+                self.remove_branch()
+            else:
+                self.values = tuple(val for val in self.values if val != value)
+
+    def flatten(self):
+        path = DatacubePath()
+        ancestors = self.get_ancestors()
+        for ancestor in ancestors:
+            path[ancestor.axis.name] = ancestor.values
+        return path
+
+    def get_ancestors(self):
+        ancestors = []
+        current_node = self
+        while current_node.axis.name != "root":
+            ancestors.append(current_node)
+            current_node = current_node.parent
+        return ancestors[::-1]

polytope_feature/datacube/transformations/__init__.py

@@ -0,0 +1 @@
+from ..transformations.datacube_transformations import *

polytope_feature/datacube/transformations/datacube_cyclic/__init__.py

@@ -0,0 +1 @@
+from .datacube_cyclic import *

polytope_feature/datacube/transformations/datacube_cyclic/datacube_cyclic.py

@@ -0,0 +1,171 @@
+import math
+from copy import deepcopy
+
+from ....utility.list_tools import unique
+from ..datacube_transformations import DatacubeAxisTransformation
+
+
+class DatacubeAxisCyclic(DatacubeAxisTransformation):
+    # The transformation here will be to point the old axes to the new cyclic axes
+
+    def __init__(self, name, cyclic_options, datacube=None):
+        self.name = name
+        self.transformation_options = cyclic_options
+        self.range = cyclic_options.range
+
+    def generate_final_transformation(self):
+        return self
+
+    def transformation_axes_final(self):
+        return [self.name]
+
+    def change_val_type(self, axis_name, values):
+        return values
+
+    def blocked_axes(self):
+        return []
+
+    def unwanted_axes(self):
+        return []
+
+    def update_range(self, axis):
+        axis.range = self.range
+
+    def _remap_range_to_axis_range(self, range, axis):
+        self.update_range(axis)
+        axis_lower = axis.range[0]
+        axis_upper = axis.range[1]
+        axis_range = axis_upper - axis_lower
+        lower = range[0]
+        upper = range[1]
+        if lower < axis_lower:
+            # In this case we need to calculate the number of loops between the axis lower
+            # and the lower to recenter the lower
+            loops = int((axis_lower - lower - axis.tol) / axis_range)
+            return_lower = lower + (loops + 1) * axis_range
+            return_upper = upper + (loops + 1) * axis_range
+        elif lower >= axis_upper:
+            # In this case we need to calculate the number of loops between the axis upper
+            # and the lower to recenter the lower
+            loops = int((lower - axis_upper) / axis_range)
+            return_lower = lower - (loops + 1) * axis_range
+            return_upper = upper - (loops + 1) * axis_range
+        else:
+            # In this case, the lower value is already in the right range
+            return_lower = lower
+            return_upper = upper
+        return [return_lower, return_upper]
+
+    def _remap_val_to_axis_range(self, value, axis):
+        value = self._remap_range_to_axis_range([value, value], axis)
+        return value[0]
+
+    def offset(self, range, axis, offset):
+        # We first unpad the range by the axis tolerance to make sure that
+        # we find the wanted range of the cyclic axis since we padded by the axis tolerance before.
+        # Also, it's safer that we find the offset of a value inside the range instead of on the border
+        unpadded_range = [range[0] + 1.5 * axis.tol, range[1] - 1.5 * axis.tol]
+        cyclic_range = self._remap_range_to_axis_range(unpadded_range, axis)
+        offset = unpadded_range[0] - cyclic_range[0]
+        return offset
+
+    def remap(self, range, ranges, axis):
+        self.update_range(axis)
+        if axis.range[0] - axis.tol <= range[0] <= axis.range[1] + axis.tol:
+            if axis.range[0] - axis.tol <= range[1] <= axis.range[1] + axis.tol:
+                # If we are already in the cyclic range, return it
+                return [range]
+        elif abs(range[0] - range[1]) <= 2 * axis.tol:
+            # If we have a range that is just one point, then it should still be counted
+            # and so we should take a small interval around it to find values inbetween
+            range = [
+                self._remap_val_to_axis_range(range[0], axis) - axis.tol,
+                self._remap_val_to_axis_range(range[0], axis) + axis.tol,
+            ]
+            return [range]
+        range_intervals = self.to_intervals(range, [[]], axis)
+        ranges = []
+        for interval in range_intervals:
+            if abs(interval[0] - interval[1]) > 0:
+                # If the interval is not just a single point, we remap it to the axis range
+                range = self._remap_range_to_axis_range([interval[0], interval[1]], axis)
+                up = range[1]
+                low = range[0]
+                if up < low:
+                    # Make sure we remap in the right order
+                    ranges.append([up - axis.tol, low + axis.tol])
+                else:
+                    ranges.append([low - axis.tol, up + axis.tol])
+        return ranges
+
+    def to_intervals(self, range, intervals, axis):
+        self.update_range(axis)
+        if range[0] == -math.inf:
+            range[0] = axis.range[0]
+        if range[1] == math.inf:
+            range[1] = axis.range[1]
+        axis_lower = axis.range[0]
+        axis_upper = axis.range[1]
+        axis_range = axis_upper - axis_lower
+        lower = range[0]
+        upper = range[1]
+        intervals = []
+        if lower < axis_upper:
+            # In this case, we want to go from lower to the first remapped cyclic axis upper
+            # or the asked upper range value.
+            # For example, if we have cyclic range [0,360] and we want to break [-270,180] into intervals,
+            # we first want to obtain [-270, 0] as the first range, where 0 is the remapped cyclic axis upper
+            # but if we wanted to break [-270, -180] into intervals, we would want to get [-270,-180],
+            # where -180 is the asked upper range value.
+            loops = int((axis_upper - lower) / axis_range)
+            remapped_up = axis_upper - (loops) * axis_range
+            new_upper = min(upper, remapped_up)
+        else:
+            # In this case, since lower >= axis_upper, we need to either go to the asked upper range
+            # or we need to go to the first remapped cyclic axis upper which is higher than lower
+            new_upper = min(axis_upper + axis_range, upper)
+            while new_upper < lower:
+                new_upper = min(new_upper + axis_range, upper)
+        intervals.append([lower, new_upper])
+        # Now that we have established what the first interval should be, we should just jump from cyclic range
+        # to cyclic range until we hit the asked upper range value.
+        new_up = deepcopy(new_upper)
+        while new_up < upper:
+            new_upper = new_up
+            new_up = min(upper, new_upper + axis_range)
+            intervals.append([new_upper, new_up])
+        # Once we have added all the in-between ranges, we need to add the last interval
+        intervals.append([new_up, upper])
+        return intervals
+
+    def find_indices_between(self, indexes_ranges, low, up, datacube, method, indexes_between_ranges, axis):
+        search_ranges = self.remap([low, up], [], axis)
+        original_search_ranges = self.to_intervals([low, up], [], axis)
+        # Find the offsets for each interval in the requested range, which we will need later
+        search_ranges_offset = []
+        for r in original_search_ranges:
+            offset = self.offset(r, axis, 0)
+            search_ranges_offset.append(offset)
+        idx_between = []
+        for i in range(len(search_ranges)):
+            r = search_ranges[i]
+            offset = search_ranges_offset[i]
+            low = r[0]
+            up = r[1]
+            indexes_between = axis.find_standard_indices_between(indexes_ranges, low, up, datacube, method)
+            # Now the indexes_between are values on the cyclic range so need to remap them to their original
+            # values before returning them
+            # if we have a special indexes between range that needs additional offset, treat it here
+            if len(indexes_between) == 0:
+                idx_between = idx_between
+            else:
+                for k in range(len(indexes_between)):
+                    if offset is None:
+                        indexes_between[k] = indexes_between[k]
+                    else:
+                        indexes_between[k] = round(indexes_between[k] + offset, int(-math.log10(axis.tol)))
+                    idx_between.append(indexes_between[k])
+        if offset is not None:
+            # Note that we can only do unique if not dealing with time values
+            idx_between = unique(idx_between)
+        return idx_between

polytope_feature/datacube/transformations/datacube_mappers/__init__.py

@@ -0,0 +1 @@
+from .datacube_mappers import *

polytope_feature/datacube/transformations/datacube_mappers/datacube_mappers.py

@@ -0,0 +1,141 @@
+from copy import deepcopy
+from importlib import import_module
+
+from ..datacube_transformations import DatacubeAxisTransformation
+
+
+class DatacubeMapper(DatacubeAxisTransformation):
+    # Needs to implements DatacubeAxisTransformation methods
+
+    def __init__(self, name, mapper_options, datacube=None):
+        self.transformation_options = mapper_options
+        self.grid_type = mapper_options.type
+        self.grid_resolution = mapper_options.resolution
+        self.grid_axes = mapper_options.axes
+        self.local_area = []
+        self.md5_hash = None
+        if mapper_options.md5_hash is not None:
+            self.md5_hash = mapper_options.md5_hash
+        if mapper_options.local is not None:
+            self.local_area = mapper_options.local
+        self._axis_reversed = None
+        if mapper_options.axis_reversed is not None:
+            self._axis_reversed = mapper_options.axis_reversed
+        self.old_axis = name
+        self._final_transformation = self.generate_final_transformation()
+        self._final_mapped_axes = self._final_transformation._mapped_axes
+        self._axis_reversed = self._final_transformation._axis_reversed
+        self.compressed_grid_axes = self._final_transformation.compressed_grid_axes
+        self.md5_hash = self._final_transformation.md5_hash
+
+    def generate_final_transformation(self):
+        map_type = _type_to_datacube_mapper_lookup[self.grid_type]
+        module = import_module(
+            "polytope_feature.datacube.transformations.datacube_mappers.mapper_types." + self.grid_type
+        )
+        constructor = getattr(module, map_type)
+        transformation = deepcopy(
+            constructor(
+                self.old_axis, self.grid_axes, self.grid_resolution, self.md5_hash, self.local_area, self._axis_reversed
+            )
+        )
+        return transformation
+
+    def blocked_axes(self):
+        return []
+
+    def unwanted_axes(self):
+        return [self._final_mapped_axes[0]]
+
+    def transformation_axes_final(self):
+        final_axes = self._final_mapped_axes
+        return final_axes
+
+    # Needs to also implement its own methods
+
+    def change_val_type(self, axis_name, values):
+        # the new axis_vals created will be floats
+        return [0.0]
+
+    def _mapped_axes(self):
+        # NOTE: Each of the mapper method needs to call it's sub mapper method
+        final_axes = self._final_mapped_axes
+        return final_axes
+
+    def _base_axis(self):
+        pass
+
+    def _resolution(self):
+        pass
+
+    def first_axis_vals(self):
+        return self._final_transformation.first_axis_vals()
+
+    def second_axis_vals(self, first_val):
+        return self._final_transformation.second_axis_vals(first_val)
+
+    def map_first_axis(self, lower, upper):
+        return self._final_transformation.map_first_axis(lower, upper)
+
+    def map_second_axis(self, first_val, lower, upper):
+        return self._final_transformation.map_second_axis(first_val, lower, upper)
+
+    def find_second_idx(self, first_val, second_val):
+        return self._final_transformation.find_second_idx(first_val, second_val)
+
+    def unmap_first_val_to_start_line_idx(self, first_val):
+        return self._final_transformation.unmap_first_val_to_start_line_idx(first_val)
+
+    def unmap(self, first_val, second_val):
+        return self._final_transformation.unmap(first_val, second_val)
+
+    def find_modified_indexes(self, indexes, path, datacube, axis):
+        if axis.name == self._mapped_axes()[0]:
+            return self.first_axis_vals()
+        if axis.name == self._mapped_axes()[1]:
+            first_val = path[self._mapped_axes()[0]]
+            if not isinstance(first_val, tuple):
+                first_val = (first_val,)
+            return self.second_axis_vals(first_val)
+
+    def unmap_path_key(self, key_value_path, leaf_path, unwanted_path, axis):
+        value = key_value_path[axis.name]
+        if axis.name == self._mapped_axes()[0]:
+            unwanted_val = key_value_path[self._mapped_axes()[0]]
+            unwanted_path[axis.name] = unwanted_val
+        if axis.name == self._mapped_axes()[1]:
+            first_val = unwanted_path[self._mapped_axes()[0]]
+            unmapped_idx = []
+            for val in value:
+                unmapped_idx.append(self.unmap(first_val, (val,)))
+            # unmapped_idx = self.unmap(first_val, value)
+            leaf_path.pop(self._mapped_axes()[0], None)
+            key_value_path.pop(axis.name)
+            key_value_path[self.old_axis] = unmapped_idx
+        return (key_value_path, leaf_path, unwanted_path)
+
+    def unmap_tree_node(self, node, unwanted_path):
+        values = node.values
+        if node.axis.name == self._mapped_axes()[0]:
+            unwanted_path[node.axis.name] = values
+            returned_node = node
+        if node.axis.name == self._mapped_axes()[1]:
+            first_vals = unwanted_path[self._mapped_axes()[0]]
+            unmapped_idxs = []
+            for first_val in first_vals:
+                for val in values:
+                    unmapped_idx = self.unmap([first_val], [val])
+                    unmapped_idxs.append(unmapped_idx)
+            returned_node = node.hide_non_index_nodes(unmapped_idxs)
+        return (returned_node, unwanted_path)
+
+
+_type_to_datacube_mapper_lookup = {
+    "octahedral": "OctahedralGridMapper",
+    "healpix": "HealpixGridMapper",
+    "regular": "RegularGridMapper",
+    "reduced_ll": "ReducedLatLonMapper",
+    "local_regular": "LocalRegularGridMapper",
+    "healpix_nested": "NestedHealpixGridMapper",
+    "reduced_gaussian": "ReducedGaussianGridMapper",
+}

polytope_feature/datacube/transformations/datacube_mappers/mapper_types/__init__.py

@@ -0,0 +1,5 @@
+from .healpix import *
+from .local_regular import *
+from .octahedral import *
+from .reduced_ll import *
+from .regular import *