a ߙfbN@sldZddlZddlZddlZddlmZddlmZmZddl m Z ddl m Z m Z ddlmZddlZddlmZdd lmZd d lmZgd Zd dZddZGdddZGdddedZGdddeZGdddeZGdddeZGdddeZ GdddeZ!Gd d!d!eZ"Gd"d#d#eZ#d$d%Z$iZ%d&e%e <d'e%e<d(e%e<d)e%e!<d*e%e"<dS)+aJ This module contains a general framework for defining graphs of transformations between coordinates, suitable for either spatial coordinates or more generalized coordinate systems. The fundamental idea is that each class is a node in the transformation graph, and transitions from one node to another are defined as functions (or methods) wrapped in transformation objects. This module also includes more specific transformation classes for celestial/spatial coordinate frames, generally focused around matrix-style transformations that are typically how the algorithms are defined. N)warn)ABCMetaabstractmethod) defaultdict)suppresscontextmanager) signature)units)AstropyWarning)matrix_product) TransformGraphCoordinateTransformFunctionTransformBaseAffineTransformAffineTransformStaticMatrixTransformDynamicMatrixTransform%FunctionTransformWithFiniteDifferenceCompositeTransformcCsi}|D]}||jq|S)z A `dict` of all the attributes of all frame classes in this `TransformGraph`. Broken out of the class so this can be called on a temporary frame set to validate new additions to the transform graph before actually adding them. )updateframe_attributes) frame_setresult frame_clsrBlib/python3.9/site-packages/astropy/coordinates/transformations.pyframe_attrs_from_set)srcCs@t}|D]0}|j}|D]}|D]}||jgq$qq |S)a  A `set` of all component names every defined within any frame class in this `TransformGraph`. Broken out of the class so this can be called on a temporary frame set to validate new additions to the transform graph before actually adding them. )setZ#_frame_specific_representation_infovaluesrZ framename)rrrZrep_infoZmappingsZrep_maprrrframe_comps_from_set9s r c@seZdZdZddZeddZeddZedd Zed d Z d d Z ddZ ddZ ddZ ddZddZddZdgddddfddZdd Zd)d"d#Zd!d$d%d&Zed'd(ZdS)*r zC A graph representing the paths between coordinate frames. cCstt|_|dSN)rdict_graphinvalidate_cacheselfrrr__init__Qs zTransformGraph.__init__cCs\|jdurVi|_}|jD]:}t|dd}|durt|tsB|g}|D] }|||<qFq|jS)Nname)_cached_names_dctrgetattr isinstancelist)r&ZdctcZnmr(rrr _cached_namesUs      zTransformGraph._cached_namescCsP|jdurFt|_|jD],}|j||j|D]}|j|q2q|jS)zT A `set` of all the frame classes present in this `TransformGraph`. N)_cached_frame_setrr#addcopy)r&abrrrrcs   zTransformGraph.frame_setcCs|jdurt|j|_|jS)zg A `dict` of all the attributes of all frame classes in this `TransformGraph`. N)_cached_frame_attributesrrr%rrrrqs  zTransformGraph.frame_attributescCs|jdurt|j|_|jS)zw A `set` of all component names every defined within any frame class in this `TransformGraph`. N)_cached_component_namesr rr%rrrframe_component_names|s  z$TransformGraph.frame_component_namescCs(d|_d|_d|_d|_i|_i|_dS)a Invalidates the cache that stores optimizations for traversing the transform graph. This is called automatically when transforms are added or removed, but will need to be called manually if weights on transforms are modified inplace. N)r)r/r4r5_shortestpaths_composite_cacher%rrrr$s zTransformGraph.invalidate_cachec Cst|stdt|s$tdt|s4td|j}||||tt| }t |}| |}|rt}|D]0} | |j vr| |g| |j vr| |gqtdt||||j||<|dS)a Add a new coordinate transformation to the graph. Parameters ---------- fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. transform : `CoordinateTransform` The transformation object. Typically a `CoordinateTransform` object, although it may be some other callable that is called with the same signature. Raises ------ TypeError If ``fromsys`` or ``tosys`` are not classes or ``transform`` is not callable. fromsys must be a classtosys must be a classztransform must be callablezFrame(s) {} contain invalid attribute names: {} Frame attributes can not conflict with *any* of the frame data component names (see `frame_transform_graph.frame_component_names`).N)inspectisclass TypeErrorcallablerr1r0rrkeysr intersectionrr ValueErrorformatr,r#r$) r&fromsystosys transformrattrscompsZ invalid_attrsZinvalid_framesattrrrr add_transforms0         zTransformGraph.add_transformcCs|dus|dur|dur |dus(td|dur8td|jD]:}|j|}|D]}|||urP||=|}qpqP|r>qq>td|dnZ|dur|j||dn>|j||d}||ur|j||ntd||||j|ikr|j||dS)a Removes a coordinate transform from the graph. Parameters ---------- fromsys : class or None The coordinate frame *class* to start from. If `None`, ``transform`` will be searched for and removed (``tosys`` must also be `None`). tosys : class or None The coordinate frame *class* to transform into. If `None`, ``transform`` will be searched for and removed (``fromsys`` must also be `None`). transform : callable or None The transformation object to be removed or `None`. If `None` and ``tosys`` and ``fromsys`` are supplied, there will be no check to ensure the correct object is removed. Nz1fromsys and tosys must both be None if either arez)cannot give all Nones to remove_transformzCould not find transform z in the graphz)Current transform from {} to {} is not {})rAr#popgetrBr$)r&rCrDrEr2agraphr3Zcurrrrrremove_transforms4    zTransformGraph.remove_transformcstd|ur(||jvr(|gdfS||jvrd|j|}|gtt|dr\|jndfS|jvr|j}||vr||SdfSg}|jD]8}||vr|||j|D]}||vr||qq|vs||vrdfSi}|jD]L}i||<} |j|} | D],}tt| |dr4| |jnd| |<qqfddt|D} | dddggi} t| dkrt | \} }}}| krd| f| |<| D]\} }}}d| f| |<qqn|| f| |<||||vrqt||D]}|| vrt t| D]}| |d |krq>qt d | |||}|| |dkr|| |d<t || |d <t | qqt| |j<| |S) a2 Computes the shortest distance along the transform graph from one system to another. Parameters ---------- fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. Returns ------- path : list of class or None The path from ``fromsys`` to ``tosys`` as an in-order sequence of classes. This list includes *both* ``fromsys`` and ``tosys``. Is `None` if there is no possible path. distance : float or int The total distance/priority from ``fromsys`` to ``tosys``. If priorities are not set this is the number of transforms needed. Is ``inf`` if there is no possible path. infrpriorityr Ncs$g|]\}}|ur||ggqSrr).0inrCrNrr Sz5TransformGraph.find_shortest_path..z+n2 not in heap - this should be impossible!)floatr#hasattrrOr7append enumerateinsertlenheapqheappoprangerAr,heapify)r&rCrDtZfpathsnodesr2r3Z edgeweightsZaewrLqrdZorderirRpathZn2rQZnewdrrSrfind_shortest_pathsl         ,          z!TransformGraph.find_shortest_pathc Cst|stdt|s$td|||\}}|dur@dSg}|}|ddD]}||j|||}qT||f}||jvrt|||dd} | |j|<|j|S)a Generates and returns the `CompositeTransform` for a transformation between two coordinate systems. Parameters ---------- fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. Returns ------- trans : `CompositeTransform` or None If there is a path from ``fromsys`` to ``tosys``, this is a transform object for that path. If no path could be found, this is `None`. Notes ----- This function always returns a `CompositeTransform`, because `CompositeTransform` is slightly more adaptable in the way it can be called than other transform classes. Specifically, it takes care of intermediate steps of transformations in a way that is consistent with 1-hop transformations. zfromsys is not a classztosys is not a classNr F)register_graph)r;r<r=rhr[r#r8r) r&rCrDrgZdistance transformsZcurrsyspZfttupleZ comptransrrr get_transform~s&    zTransformGraph.get_transformcCs|j|dS)aa Tries to locate the coordinate class with the provided alias. Parameters ---------- name : str The alias to look up. Returns ------- `BaseCoordinateFrame` subclass The coordinate class corresponding to the ``name`` or `None` if no such class exists. N)r.rK)r&r(rrr lookup_nameszTransformGraph.lookup_namecCst|jS)z Returns all available transform names. They will all be valid arguments to `lookup_name`. Returns ------- nms : list The aliases for coordinate systems. )r,r.r?r%rrr get_namess zTransformGraph.get_namesTNplainc"sg}jD]8}||vr ||j|D]} | |vr*|| q*q |D]} | |vrH|| qHg} tfddjD} |D]@} | | vrd| | }| d| j|q| | jdqg}jD]^}j|}|D]J} || }t|dr|jnd}|rt |j nd}||j| j||fqqd g}|d |d | d |D]\\}}}}d }|rxd|d}nd}d|d}|||}||d||d qT|d|d|dd|}|dur|dkr&t |d}| |Wdn1s0Yn|g}|durD|d|t j|t jt jt jd}||\} }!|jdkrtd|!t |d}| | Wdn1s0Y|S)a Converts this transform graph to the graphviz_ DOT format. Optionally saves it (requires `graphviz`_ be installed and on your path). .. _graphviz: http://www.graphviz.org/ Parameters ---------- priorities : bool If `True`, show the priority values for each transform. Otherwise, the will not be included in the graph. addnodes : sequence of str Additional coordinate systems to add (this can include systems already in the transform graph, but they will only appear once). savefn : None or str The file name to save this graph to or `None` to not save to a file. savelayout : str The graphviz program to use to layout the graph (see graphviz_ for details) or 'plain' to just save the DOT graph content. Ignored if ``savefn`` is `None`. saveformat : str The graphviz output format. (e.g. the ``-Txxx`` option for the command line program - see graphviz docs for details). Ignored if ``savefn`` is `None`. color_edges : bool Color the edges between two nodes (frames) based on the type of transform. ``FunctionTransform``: red, ``StaticMatrixTransform``: blue, ``DynamicMatrixTransform``: green. Returns ------- dotgraph : str A string with the DOT format graph. cs(g|] fddjDfqS)csg|]\}}|kr|qSrrrPkvfrrrTrUz:TransformGraph.to_dot_graph...)r.items)rPr%rsrrTsz/TransformGraph.to_dot_graph..z`\n`z#{0} [shape=oval label="{0}\n`{1}`"]z[ shape=oval ]rOr Zblackz)digraph AstropyCoordinateTransformGraph {zgraph [rankdir=LR]z; ;z [ {0} {1} ]z label = ""z color = "z -> z overlap=false} Nrowz-T)stdinstdoutstderrrzproblem running graphviz: )r#r[r"rjoinrB__name__rZrOtrans_to_color __class__openwrite subprocessPopenPIPEZ communicate returncodeOSError)"r&Z prioritiesZaddnodesZsavefnZ savelayoutZ saveformatZ color_edgesrdr2r3ZnodeZ nodenamesZ invclsaliasesrRaliasesZ edgenamesrLrEpricolorlinesZenm1Zenm2ZweightsZ labelstr_fmtZ priority_partZ color_partZlabelstrZdotgraphrtargsprocr}r~rr%r to_dot_graphsv'                ,     *zTransformGraph.to_dot_graphc Csddl}|}|jD]8}||vr,|||j|D]}||vr6||q6q|jD]P}|j|}|D]<}||}t|dr|jnd}t|j}|j||||dqhqV|S)a Converts this transform graph into a networkx graph. .. note:: You must have the `networkx `_ package installed for this to work. Returns ------- nxgraph : ``networkx.Graph`` This `TransformGraph` as a `networkx.Graph `_. rNrOr )Zweightr) ZnetworkxZGraphr#Zadd_noderZrOrrZadd_edge) r&ZnxZnxgraphr2r3rLrErrrrrto_networkx_graph?s      z TransformGraph.to_networkx_graphr c sfdd}|S)a A function decorator for defining transformations. .. note:: If decorating a static method of a class, ``@staticmethod`` should be added *above* this decorator. Parameters ---------- transcls : class The class of the transformation object to create. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. Additional keyword arguments are passed into the ``transcls`` constructor. Returns ------- deco : function A function that can be called on another function as a decorator (see example). Notes ----- This decorator assumes the first argument of the ``transcls`` initializer accepts a callable, and that the second and third are ``fromsys`` and ``tosys``. If this is not true, you should just initialize the class manually and use `add_transform` instead of using this decorator. Examples -------- :: graph = TransformGraph() class Frame1(BaseCoordinateFrame): ... class Frame2(BaseCoordinateFrame): ... @graph.transform(FunctionTransform, Frame1, Frame2) def f1_to_f2(f1_obj): ... do something with f1_obj ... return f2_obj cs|fd|SNrOrir)funcrCkwargsrOr&rDtransclsrrdecos  z&TransformGraph.transform..decor)r&rrCrDrOrrrrrrEcs7zTransformGraph.transformrOc s||g|}|d}||}fddt|dd|ddD}d|vrXtdt|jdkrtd|jd|jd ||t||||d dS) a Add a single-step transform that encapsulates a multi-step transformation path, using the transforms that already exist in the graph. The created transform internally calls the existing transforms. If all of the transforms are affine, the merged transform is `~astropy.coordinates.transformations.DynamicMatrixTransform` (if there are no origin shifts) or `~astropy.coordinates.transformations.AffineTransform` (otherwise). If at least one of the transforms is not affine, the merged transform is `~astropy.coordinates.transformations.FunctionTransformWithFiniteDifference`. This method is primarily useful for defining loopback transformations (i.e., where ``fromsys`` and the final ``tosys`` are the same). Parameters ---------- fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform to. *furthersys : class Additional coordinate frame classes to transform to in order. priority : number The priority of this transform when finding the shortest coordinate transform path - large numbers are lower priorities. Notes ----- Even though the created transform is a single step in the graph, it will still internally call the constituent transforms. Thus, there is no performance benefit for using this created transform. For Astropy's built-in frames, loopback transformations typically use `~astropy.coordinates.ICRS` to be safe. Tranforming through an inertial frame ensures that changes in observation time and observer location/velocity are properly accounted for. An error will be raised if a direct transform between ``fromsys`` and ``tosys`` already exist. rVcsg|]\}}||qSr)rl)rPZframe_aZframe_br%rrrTsz8TransformGraph._add_merged_transform..Nr z(This transformation path is not possiblezA direct transform for z->z already existsr) rlziprAr^rjrrIr_as_single_transform) r&rCrDrOZ furthersysZframesZlastsys full_pathrjrr%r_add_merged_transforms*   z$TransformGraph._add_merged_transformc csd}g}zj|jD]B}|D]4}t||r ||t||f}||t|||q qdVW|D] }t|qdn|D] }t|qx0dS)a Context manager to impose a finite-difference time step on all applicable transformations For each transformation in this transformation graph that has the attribute ``finite_difference_dt``, that attribute is set to the provided value. The only standard transformation with this attribute is `~astropy.coordinates.transformations.FunctionTransformWithFiniteDifference`. Parameters ---------- dt : `~astropy.units.Quantity` ['time'] or callable If a quantity, this is the size of the differential used to do the finite difference. If a callable, should accept ``(fromcoord, toframe)`` and return the ``dt`` value. finite_difference_dtN)r#rrZr*r[setattr)r&dtkeyZsaved_settingsZ to_framesrEZ old_settingZsettingrrrimpose_finite_difference_dts    z*TransformGraph.impose_finite_difference_dt)r )r __module__ __qualname____doc__r'propertyr.rrr6r$rIrMrhrlrmrnrrrErrrrrrrr Ls2    :9v3  p$ @8r c@s6eZdZdZd ddZddZdd Zed d ZdS) ra0 An object that transforms a coordinate from one system to another. Subclasses must implement `__call__` with the provided signature. They should also call this superclass's ``__init__`` in their ``__init__``. Parameters ---------- fromsys : `~astropy.coordinates.BaseCoordinateFrame` subclass The coordinate frame class to start from. tosys : `~astropy.coordinates.BaseCoordinateFrame` subclass The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. r NcCst|stdt|s$td||_||_t||_|rJ||nt|r^t|sftdg|_}t |drt |dr|j D]}||j vr| |qdS)Nr9r:z!fromsys and tosys must be classesget_frame_attr_names) r;r<r=rCrDrYrOregisterZoverlapping_frame_attr_namesrZrr?r[)r&rCrDrOriZoverlapZfrom_nmrrrr's$      zCoordinateTransform.__init__cCs||j|j|dS)a  Add this transformation to the requested Transformation graph, replacing anything already connecting these two coordinates. Parameters ---------- graph : `TransformGraph` object The graph to register this transformation with. N)rIrCrDr&Zgraphrrrr,s zCoordinateTransform.registercCs||j|j|dS)aY Remove this transformation from the requested transformation graph. Parameters ---------- graph : a TransformGraph object The graph to unregister this transformation from. Raises ------ ValueError If this is not currently in the transform graph. N)rMrCrDrrrr unregister8szCoordinateTransform.unregistercCsdS)as Does the actual coordinate transformation from the ``fromsys`` class to the ``tosys`` class. Parameters ---------- fromcoord : `~astropy.coordinates.BaseCoordinateFrame` subclass instance An object of class matching ``fromsys`` that is to be transformed. toframe : object An object that has the attributes necessary to fully specify the frame. That is, it must have attributes with names that match the keys of the dictionary that ``tosys.get_frame_attr_names()`` returns. Typically this is of class ``tosys``, but it *might* be some other class as long as it has the appropriate attributes. Returns ------- tocoord : `BaseCoordinateFrame` subclass instance The new coordinate after the transform has been applied. Nrr& fromcoordtoframerrr__call__IszCoordinateTransform.__call__)r N) rrrrr'rrrrrrrrrs   r) metaclasscs*eZdZdZdfdd ZddZZS) ra  A coordinate transformation defined by a function that accepts a coordinate object and returns the transformed coordinate object. Parameters ---------- func : callable The transformation function. Should have a call signature ``func(formcoord, toframe)``. Note that, unlike `CoordinateTransform.__call__`, ``toframe`` is assumed to be of type ``tosys`` for this function. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. Raises ------ TypeError If ``func`` is not callable. ValueError If ``func`` cannot accept two arguments. r Ncst|stdttXt|ddjD}tfdd|Ddkrbj|vrbtdWdn1sv0Y||_ t j ||||ddS) Nzfunc must be callablecSsg|] }|jqSr)kindrPxrrrrTrUz.FunctionTransform.__init__..c3s|]}|jkr|VqdSr!)ZPOSITIONAL_ONLYrZsigrr rUz-FunctionTransform.__init__..rWz/provided function does not accept two argumentsr) r>r=rr parametersrr^ZVAR_POSITIONALrArsuperr')r&rrCrDrOriZkindsrrrr's & zFunctionTransform.__init__cCsL|||}t||js.td|d|j|jjrH|jjsHtdt|S)Nz$the transformation function yielded z but should have been of type zApplied a FunctionTransform to a coordinate frame with differentials, but the FunctionTransform does not handle differentials, so they have been dropped.)rr+rDr=data differentialsrr )r&rrresrrrrs   zFunctionTransform.__call__)r N)rrrrr'r __classcell__rrrrras rcsTeZdZdZddddejdffdd Zedd Zej d d Zd d Z Z S) ra  A coordinate transformation that works like a `FunctionTransform`, but computes velocity shifts based on the finite-difference relative to one of the frame attributes. Note that the transform function should *not* change the differential at all in this case, as any differentials will be overridden. When a differential is in the from coordinate, the finite difference calculation has two components. The first part is simple the existing differential, but re-orientation (using finite-difference techniques) to point in the direction the velocity vector has in the *new* frame. The second component is the "induced" velocity. That is, the velocity intrinsic to the frame itself, estimated by shifting the frame using the ``finite_difference_frameattr_name`` frame attribute a small amount (``finite_difference_dt``) in time and re-calculating the position. Parameters ---------- finite_difference_frameattr_name : str or None The name of the frame attribute on the frames to use for the finite difference. Both the to and the from frame will be checked for this attribute, but only one needs to have it. If None, no velocity component induced from the frame itself will be included - only the re-orientation of any existing differential. finite_difference_dt : `~astropy.units.Quantity` ['time'] or callable If a quantity, this is the size of the differential used to do the finite difference. If a callable, should accept ``(fromcoord, toframe)`` and return the ``dt`` value. symmetric_finite_difference : bool If True, the finite difference is computed as :math:`\frac{x(t + \Delta t / 2) - x(t + \Delta t / 2)}{\Delta t}`, or if False, :math:`\frac{x(t + \Delta t) - x(t)}{\Delta t}`. The latter case has slightly better performance (and more stable finite difference behavior). All other parameters are identical to the initializer for `FunctionTransform`. r NZobstimeTc s*t|||||||_||_||_dSr!)rr' finite_difference_frameattr_namersymmetric_finite_difference) r&rrCrDrOrirrrrrrr'sz.FunctionTransformWithFiniteDifference.__init__cCs|jSr!)!_finite_difference_frameattr_namer%rrrrszFFunctionTransformWithFiniteDifference.finite_difference_frameattr_namecCsd|durd|_|_nD||jjv}||jjv}|s6|rD||_||_ntd||j|j||_dS)NFzr realize_framewithout_differentialsZ cartesianrZxyzZd_xyzrrr*Z replicaterZreplicate_without_data to_cartesianwith_differentials)r&rrrrZsupcallrZhalfdtZ from_difflessZreprwithoutdiffZfromcoord_cartZfwdxyzZfwdZbackxyzZbackZdiffxyzattrnameZkwsZfrom_diffless_fwdZ fwd_frameZfrom_diffless_backZ back_framenewdiffZ reprwithdiffrrrrsz        z.FunctionTransformWithFiniteDifference.__call__) rrrrusecondr'rrsetterrrrrrrrs(   rc@s,eZdZdZddZddZeddZdS) ra]Base class for common functionality between the ``AffineTransform``-type subclasses. This base class is needed because ``AffineTransform`` and the matrix transform classes share the ``__call__()`` method, but differ in how they generate the affine parameters. ``StaticMatrixTransform`` passes in a matrix stored as a class attribute, and both of the matrix transforms pass in ``None`` for the offset. Hence, user subclasses would likely want to subclass this (rather than ``AffineTransform``) if they want to provide alternative transformations using this machinery. csHddlm}mm}m}m}|jdjv}|dur@|dur@S|j|jf} |o^t jd| } |ort jd|} t |r|durt d j nX|r| s| r|durd|jvrt d jdj n"t jdkrtd tj|r8t |r8| s8| s8jdjdj} d| in| rF} tfddjD}| |} |dur| |} |dur| |}n| }|r| s| jd}|durd|jvr||jd}|d|i}t |j|r|r| s| s|jd|jjdj}||tfd djD}|jjdj|d <d|jjdj fd d i|i}n8|r| r|jd|jjdj |di}n|j}||jj }||}n<|r| r|jjdj }||jj |j}||jj |}|rD| rD||jj }|d|jjdi}|S) Nr )UnitSphericalRepresentationrSphericalDifferentialSphericalCosLatDifferentialRadialDifferentialrzPosition information stored on coordinate frame is insufficient to do a full-space position transformation (representation class: {})zVelocity information stored on coordinate frame is insufficient to do a full-space velocity transformation (differential class: {})zRepresentation passed to AffineTransform contains multiple associated differentials. Only a single differential with velocity units is presently supported (differentials: {}).cs g|]\}}||fqSr) represent_as)rPrqZdiff)rrrrrTsz8BaseAffineTransform._apply_transform..csg|]}|t|fqSrr*)rPcomp)rrrrTs d_distancer1F)rrrrrrrrZ_unit_differentialr+r=rBrr^rAstrrrrrr"rurEZ componentsrZ_dimensional_differential)r&rmatrixoffsetrrrrZ has_velocityZ _unit_diffsZ unit_vel_diffZ rad_vel_diffZ unit_diffZrepZdiffsnewrepZveldiffZ _unit_clsrZdiff_clsr)rrrr_apply_transformGs                       z$BaseAffineTransform._apply_transformcCs(|||}|j|g|R}||Sr!)_affine_paramsrr)r&rrparamsrrrrrs zBaseAffineTransform.__call__cCsdSr!rrrrrrsz"BaseAffineTransform._affine_paramsN)rrrrrrrrrrrrr:s  rcs*eZdZdZdfdd ZddZZS) ra A coordinate transformation specified as a function that yields a 3 x 3 cartesian transformation matrix and a tuple of displacement vectors. See `~astropy.coordinates.builtin_frames.galactocentric.Galactocentric` for an example. Parameters ---------- transform_func : callable A callable that has the signature ``transform_func(fromcoord, toframe)`` and returns: a (3, 3) matrix that operates on ``fromcoord`` in a Cartesian representation, and a ``CartesianRepresentation`` with (optionally) an attached velocity ``CartesianDifferential`` to represent a translation and offset in velocity to apply after the matrix operation. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. Raises ------ TypeError If ``transform_func`` is not callable r Ncs.t|std||_tj||||ddS)Nztransform_func is not callabler)r>r=transform_funcrr')r&rrCrDrOrirrrr's  zAffineTransform.__init__cCs |||Sr!)rrrrrrszAffineTransform._affine_params)r Nrrrrr'rrrrrrrs " rcs*eZdZdZdfdd ZddZZS) ra: A coordinate transformation defined as a 3 x 3 cartesian transformation matrix. This is distinct from DynamicMatrixTransform in that this kind of matrix is independent of frame attributes. That is, it depends *only* on the class of the frame. Parameters ---------- matrix : array-like or callable A 3 x 3 matrix for transforming 3-vectors. In most cases will be unitary (although this is not strictly required). If a callable, will be called *with no arguments* to get the matrix. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. Raises ------ ValueError If the matrix is not 3 x 3 r NcsFt|r|}t||_|jjdkr.tdtj||||ddS)N)rXrXzProvided matrix is not 3 x 3r)r>npZarrayrshaperArr')r&rrCrDrOrirrrr'>s   zStaticMatrixTransform.__init__cCs |jdfSr!)rrrrrrIsz$StaticMatrixTransform._affine_params)r Nrrrrrrs  rcs*eZdZdZdfdd ZddZZS) ra+ A coordinate transformation specified as a function that yields a 3 x 3 cartesian transformation matrix. This is similar to, but distinct from StaticMatrixTransform, in that the matrix for this class might depend on frame attributes. Parameters ---------- matrix_func : callable A callable that has the signature ``matrix_func(fromcoord, toframe)`` and returns a 3 x 3 matrix that converts ``fromcoord`` in a cartesian representation to the new coordinate system. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. Raises ------ TypeError If ``matrix_func`` is not callable r Ncs.t|std||_tj||||ddS)Nzmatrix_func is not callabler)r>r= matrix_funcrr')r&rrCrDrOrirrrr'ms  zDynamicMatrixTransform.__init__cCs|||dfSr!)rrrrrrvsz%DynamicMatrixTransform._affine_params)r NrrrrrrMs  rcs:eZdZdZd fdd ZddZd d Zd d ZZS)ra A transformation constructed by combining together a series of single-step transformations. Note that the intermediate frame objects are constructed using any frame attributes in ``toframe`` or ``fromframe`` that overlap with the intermediate frame (``toframe`` favored over ``fromframe`` if there's a conflict). Any frame attributes that are not present use the defaults. Parameters ---------- transforms : sequence of `CoordinateTransform` object The sequence of transformations to apply. fromsys : class The coordinate frame class to start from. tosys : class The coordinate frame class to transform into. priority : float or int The priority if this transform when finding the shortest coordinate transform path - large numbers are lower priorities. register_graph : `TransformGraph` or None A graph to register this transformation with on creation, or `None` to leave it unregistered. collapse_static_mats : bool If `True`, consecutive `StaticMatrixTransform` will be collapsed into a single transformation to speed up the calculation. r NTcs0tj||||d|r"||}t||_dSr)rr'_combine_staticstuplerj)r&rjrCrDrOriZcollapse_static_matsrrrr's   zCompositeTransform.__init__cCslg}|D]^}t|dkr |dnd}t|tr\t|tr\t|j|j}t||j|j|d<q||q|S)zy Combines together sequences of `StaticMatrixTransform`s into a single transform and returns it. rrVN)r^r+rr rrCrDr[)r&rjZnewtransZ currtransZ lasttransZ combinedmatrrrrs   z#CompositeTransform._combine_staticsc Cs||}|jD]l}i}|jD]>}t||r>t||}|||<qt||rt||}|||<q|jfi|}|||}q |Sr!)rjrDrrZr*) r&rrZ curr_coordrcZfrattrsZinter_frame_attr_nmrHZ curr_toframerrrrs        zCompositeTransform.__call__csvddjDtddDrPtddDfdd}rJtnt}nfdd}t}||jjjdS) ax Return an encapsulated version of the composite transform so that it appears to be a single transform. The returned transform internally calls the constituent transforms. If all of the transforms are affine, the merged transform is `~astropy.coordinates.transformations.DynamicMatrixTransform` (if there are no origin shifts) or `~astropy.coordinates.transformations.AffineTransform` (otherwise). If at least one of the transforms is not affine, the merged transform is `~astropy.coordinates.transformations.FunctionTransformWithFiniteDifference`. cSs"g|]}t|ts|n|qSr)r+rrrPrcrrrrTsz;CompositeTransform._as_single_transform..cSsg|]}t|tqSr)r+rrrrrrTrUcSsg|]}t|ttfqSr)r+rrrrrrrTscsrrdSdSfddjD}|fddjDd}tD]\}|dkrvfddjD}nfdd|D}fdd|D}jjfi|jfi|}t ||}qPr|dS|S) N)NNcsi|]}|t|qSrrrPr(from_coorr szUCompositeTransform._as_single_transform..single_transform..csi|]}|t|qSrrr)to_framerrrsrcsi|]}|t|qSrrrrrrrscs"i|]\}}|jjvr||qSr)rCrrprcrrrs  cs"i|]\}}|jjvr||qSr)rDrrprrrrs  ) is_equivalent_framerrr\rurrCrrD_combine_affine_params)rrZ merged_attrZ affine_paramsrQZa_attrZb_attrZnext_affine_params) fixed_originrj)rrcrrsingle_transforms*     zACompositeTransform._as_single_transform..single_transformcs ||r||jS||Sr!)rrr)rrr%rrrs  r)rjallrrrrCrDrO)r&rZtransform_typer)rr&rjrrs+ z'CompositeTransform._as_single_transform)r NT) rrrrr'rrrrrrrrrzs rc Cs|\}}|\}}|dur*|dur*||}n|dur6|n|}|dur|durT||}|durd|jvrd|jvr|jd|jd}||}|d|i}q||}q|}n|}||fS)a Combine two sets of affine parameters. The parameters for an affine transformation are a 3 x 3 Cartesian transformation matrix and a displacement vector, which can include an attached velocity. Either type of parameter can be ``None``. Nr)rErrr) rZ next_paramsMZvecZnext_MZnext_vecZnew_MZnew_vec_velocityZnew_vecrrrrs"   rz#555555z#783001z#d95f02z#7570b3z#1b9e77)&rr_r;rwarningsrabcrr collectionsr contextlibrrrZnumpyrZastropyr rZastropy.utils.exceptionsr Zmatrix_utilitiesr __all__rr r rrrrrrrrrrrrrrsN      6d=310-#)