Spring cleaning coordinate frames

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: test
 on:
   push:
     branches:
-      - 'master'
+      - '*'
     tags:
       - '*'
   pull_request:

CHANGES.rst

@@ -1,6 +1,16 @@
 0.22.0 (unreleased)
 -------------------
 
+- Coordinate frames now have a "native" order and then are sorted based on ``axes_order``. [#457]
+
+- ``WCS.numerical_inverse`` no longer accepts high level objects (``with_units=`` is not supported) use ``WCS.inverse``. [#457]
+
+- ``CoordinateFrame.coordinates`` has been replaced by ``CoordinateFrame.to_high_level_coordinates`` [#457]
+
+- ``CoordinateFrame.to_quantity`` has been replaced by ``CoordinateFrame.from_high_level_coordinates``. [#457]
+
+- Inputs to ``CelestialFrame``, such as ``axes_names`` are now explicitly in lon, lat order and will re sorted based on ``axes_order=``. [#457]
+
 - Replace usages of ``copy_arrays`` with ``memmap`` [#503]
 
 - Fix an issue with units in ``wcs_from_points``. [#507]

docs/index.rst

@@ -100,7 +100,7 @@ To install the latest release::
 
     pip install gwcs
 
-The latest release of GWCS is also available as part of `astroconda <https://github.com/astroconda/astroconda>`__.
+The latest release of GWCS is also available as a conda package via `conda-forge <https://github.com/conda-forge/gwcs-feedstock>`__.
 
 
 .. _getting-started:
@@ -240,13 +240,7 @@ To convert a pixel (x, y) = (1, 2) to sky coordinates, call the WCS object as a
 The :meth:`~gwcs.wcs.WCS.invert` method evaluates the :meth:`~gwcs.wcs.WCS.backward_transform`
 if available, otherwise applies an iterative method to calculate the reverse coordinates.
 
-.. doctest-skip::
-
-  >>> wcsobj.invert(*sky)
-  (0.9999999996185807, 1.999999999186798)
-
-GWCS supports the common WCS interface which defines several methods
-to work with high level Astropy objects:
+GWCS supports the :ref:`wcsapi` which defines several methods to work with high level Astropy objects:
 
 .. doctest-skip::
 

gwcs/api.py

@@ -5,17 +5,16 @@
 
 """
 
-from astropy.wcs.wcsapi import BaseHighLevelWCS, BaseLowLevelWCS
+from astropy.wcs.wcsapi import BaseLowLevelWCS, HighLevelWCSMixin
 from astropy.modeling import separable
 import astropy.units as u
 
-from . import utils
-from . import coordinate_frames as cf
+from gwcs import utils
 
 __all__ = ["GWCSAPIMixin"]
 
 
-class GWCSAPIMixin(BaseHighLevelWCS, BaseLowLevelWCS):
+class GWCSAPIMixin(BaseLowLevelWCS, HighLevelWCSMixin):
     """
     A mix-in class that is intended to be inherited by the
     :class:`~gwcs.wcs.WCS` class and provides the low- and high-level
@@ -52,14 +51,7 @@ def world_axis_physical_types(self):
         arbitrary string.  Alternatively, if the physical type is
         unknown/undefined, an element can be `None`.
         """
-        # A CompositeFrame orders the output correctly based on axes_order.
-        if isinstance(self.output_frame, cf.CompositeFrame):
-            return self.output_frame.axis_physical_types
-
-        # If we don't have a CompositeFrame, where this is taken care of for us,
-        # we need to make sure we re-order the output to match the transform.
-        # The underlying frames don't reorder themselves because axes_order is global.
-        return tuple(self.output_frame.axis_physical_types[i] for i in self.output_frame.axes_order)
+        return self.output_frame.axis_physical_types
 
     @property
     def world_axis_units(self):
@@ -75,22 +67,17 @@ def world_axis_units(self):
 
     def _remove_quantity_output(self, result, frame):
         if self.forward_transform.uses_quantity:
-            if self.output_frame.naxes == 1:
+            if frame.naxes == 1:
                 result = [result]
 
-            result = tuple(r.to_value(unit) for r, unit in zip(result, frame.unit))
+            result = tuple(r.to_value(unit) if isinstance(r, u.Quantity) else r
+                           for r, unit in zip(result, frame.unit))
 
         # If we only have one output axes, we shouldn't return a tuple.
         if self.output_frame.naxes == 1 and isinstance(result, tuple):
             return result[0]
         return result
 
-    def _add_units_input(self, arrays, transform, frame):
-        if transform.uses_quantity:
-            return tuple(u.Quantity(array, unit) for array, unit in zip(arrays, frame.unit))
-
-        return arrays
-
     def pixel_to_world_values(self, *pixel_arrays):
         """
         Convert pixel coordinates to world coordinates.
@@ -104,8 +91,7 @@ def pixel_to_world_values(self, *pixel_arrays):
         order, where for an image, ``x`` is the horizontal coordinate and ``y``
         is the vertical coordinate.
         """
-        pixel_arrays = self._add_units_input(pixel_arrays, self.forward_transform, self.input_frame)
-        result = self(*pixel_arrays, with_units=False)
+        result = self._call_forward(*pixel_arrays)
 
         return self._remove_quantity_output(result, self.output_frame)
 
@@ -132,15 +118,7 @@ def world_to_pixel_values(self, *world_arrays):
         be returned in the ``(x, y)`` order, where for an image, ``x`` is the
         horizontal coordinate and ``y`` is the vertical coordinate.
         """
-        try:
-            backward_transform = self.backward_transform
-            world_arrays = self._add_units_input(world_arrays,
-                                                 backward_transform,
-                                                 self.output_frame)
-        except NotImplementedError:
-            pass
-
-        result = self.invert(*world_arrays, with_units=False)
+        result = self._call_backward(*world_arrays)
 
         return self._remove_quantity_output(result, self.input_frame)
 
@@ -269,77 +247,11 @@ def serialized_classes(self):
 
     @property
     def world_axis_object_classes(self):
-        return self.output_frame._world_axis_object_classes
+        return self.output_frame.world_axis_object_classes
 
     @property
     def world_axis_object_components(self):
-        return self.output_frame._world_axis_object_components
-
-    # High level APE 14 API
-
-    @property
-    def low_level_wcs(self):
-        """
-        Returns a reference to the underlying low-level WCS object.
-        """
-        return self
-
-    def _sanitize_pixel_inputs(self, *pixel_arrays):
-        pixels = []
-        if self.forward_transform.uses_quantity:
-            for i, pixel in enumerate(pixel_arrays):
-                if not isinstance(pixel, u.Quantity):
-                    pixel = u.Quantity(value=pixel, unit=self.input_frame.unit[i])
-                pixels.append(pixel)
-        else:
-            for i, pixel in enumerate(pixel_arrays):
-                if isinstance(pixel, u.Quantity):
-                    if pixel.unit != self.input_frame.unit[i]:
-                        raise ValueError('Quantity input does not match the '
-                                         'input_frame unit.')
-                    pixel = pixel.value
-                pixels.append(pixel)
-
-        return pixels
-
-    def pixel_to_world(self, *pixel_arrays):
-        """
-        Convert pixel values to world coordinates.
-        """
-        pixels = self._sanitize_pixel_inputs(*pixel_arrays)
-        return self(*pixels, with_units=True)
-
-    def array_index_to_world(self, *index_arrays):
-        """
-        Convert array indices to world coordinates (represented by Astropy
-        objects).
-        """
-        pixel_arrays = index_arrays[::-1]
-        pixels = self._sanitize_pixel_inputs(*pixel_arrays)
-        return self(*pixels, with_units=True)
-
-    def world_to_pixel(self, *world_objects):
-        """
-        Convert world coordinates to pixel values.
-        """
-        result = self.invert(*world_objects, with_units=True)
-        if self.input_frame.naxes > 1:
-            first_res = result[0]
-            if not utils.isnumerical(first_res):
-                result = [i.value for i in result]
-        else:
-            if not utils.isnumerical(result):
-                result = result.value
-
-        return result
-
-    def world_to_array_index(self, *world_objects):
-        """
-        Convert world coordinates (represented by Astropy objects) to array
-        indices.
-        """
-        result = self.invert(*world_objects, with_units=True)[::-1]
-        return tuple([utils._toindex(r) for r in result])
+        return self.output_frame.world_axis_object_components
 
     @property
     def pixel_axis_names(self):

gwcs/converters/wcs.py

@@ -147,19 +147,8 @@ def from_yaml_tree(self, node, tag, ctx):
         from ..coordinate_frames import SpectralFrame
         node = self._from_yaml_tree(node, tag, ctx)
 
-        if 'reference_position' in node:
-            node['reference_position'] = node['reference_position'].upper()
-
         return SpectralFrame(**node)
 
-    def to_yaml_tree(self, frame, tag, ctx):
-        node = self._to_yaml_tree(frame, tag, ctx)
-
-        if frame.reference_position is not None:
-            node['reference_position'] = frame.reference_position.lower()
-
-        return node
-
 
 class CompositeFrameConverter(FrameConverter):
     tags = ["tag:stsci.edu:gwcs/composite_frame-*"]