diff options
Diffstat (limited to 'ast/region.c')
| -rw-r--r-- | ast/region.c | 13502 |
1 files changed, 0 insertions, 13502 deletions
diff --git a/ast/region.c b/ast/region.c deleted file mode 100644 index 5148917..0000000 --- a/ast/region.c +++ /dev/null @@ -1,13502 +0,0 @@ -/* -*class++ -* Name: -* Region - -* Purpose: -* Represents a region within a coordinate system. - -* Constructor Function: -* None. - -* Description: -* This class provides the basic facilities for describing a region within -* a specified coordinate system. However, the Region class does not -* have a constructor function of its own, as it is simply a container -* class for a family of specialised sub-classes such as Circle, Box, etc, -* which implement Regions with particular shapes. -* -* All sub-classes of Region require a Frame to be supplied when the Region -* is created. This Frame describes the coordinate system in which the -* Region is defined, and is referred to as the "encapsulated Frame" below. -* Constructors will also typically required one or more positions to be -* supplied which define the location and extent of the region. These -* positions must be supplied within the encapsulated Frame. -* -* The Region class inherits from the Frame class, and so a Region can be -* supplied where-ever a Frame is expected. In these cases, supplying a -* Region is equivalent to supplying a reference to its encapsulated Frame. -* Thus all the methods of the Frame class can be used on the Region class. -* For instance, the -c astFormat function -f AST_FORMAT routine -* may be used on a Region to format an axis value. -* -* In addition, since Frame inherits from Mapping, a Region is also a sort -* of Mapping. Transforming positions by supplying a Region to one of the -c astTran<X> functions -f AST_TRAN<X> routines -* is the way to determine if a given position is inside or outside the -* Region. When used as a Mapping, most classes of Frame are equivalent to -* a UnitMap. However, the Region class modifies this behaviour so that a -* Region acts like a UnitMap only for input positions which are within the -* area represented by the Region. Input positions which are outside the -* area produce bad output values (i.e. the output values are equal to -* AST__BAD). This behaviour is the same for both the forward and the -* inverse transformation. In this sense the "inverse transformation" -* is not a true inverse of the forward transformation, since applying -* the forward transformation to a point outside the Region, and then -* applying the inverse transformation results, in a set of AST__BAD axis -* values rather than the original axis values. If required, the -c astRemoveRegions -f AST_REMOVEREGIONS -* function can be used to remove the "masking" effect of any Regions -* contained within a compound Mapping or FrameSet. It does this by -* replacing each Region with a UnitMap or equivalent Frame (depending -* on the context in which the Region is used). -* -* If the coordinate system represented by the Region is changed (by -* changing the values of one or more of the attribute which the Region -* inherits from its encapsulated Frame), the area represented by -* the Region is mapped into the new coordinate system. For instance, let's -* say a Circle (a subclass of Region) is created, a SkyFrame being -* supplied to the constructor so that the Circle describes a circular -* area on the sky in FK4 equatorial coordinates. Since Region inherits -* from Frame, the Circle will have a System attribute and this attribute -* will be set to "FK4". If the System attribute of the Region is then -* changed from FK4 to FK5, the circular area represented by the Region -* will automatically be mapped from the FK4 system into the FK5 system. -* In general, changing the coordinate system in this way may result in the -* region changing shape - for instance, a circle may change into an -* ellipse if the transformation from the old to the new coordinate system -* is linear but with different scales on each axis. Thus the specific -* class of a Region cannot be used as a guarantee of the shape in any -* particular coordinate system. If the -c astSimplify function -f AST_SIMPLIFY routine -* is used on a Region, it will endeavour to return a new Region of -* a sub-class which accurately describes the shape in the current -* coordinate system of the Region (but this may not always be possible). -* -* It is possible to negate an existing Region so that it represents all -* areas of the encapsulated Frame except for the area specified when -* the Region was created. - -* Inheritance: -* The Region class inherits from the Frame class. - -* Attributes: -* In addition to those attributes common to all Frames, every -* Region also has the following attributes: -* -* - Adaptive: Should the area adapt to changes in the coordinate system? -* - Negated: Has the original region been negated? -* - Closed: Should the boundary be considered to be inside the region? -* - MeshSize: Number of points used to create a mesh covering the Region -* - FillFactor: Fraction of the Region which is of interest -* - Bounded: Is the Region bounded? -* -* Every Region also inherits any further attributes that belong -* to the encapsulated Frame, regardless of that Frame's class. (For -* example, the Equinox attribute, defined by the SkyFrame class, is -* inherited by any Region which represents a SkyFrame.) - -* Functions: -c In addition to those functions applicable to all Frames, the -c following functions may also be applied to all Regions: -f In addition to those routines applicable to all Frames, the -f following routines may also be applied to all Regions: -* -c - astGetRegionBounds: Get the bounds of a Region -f - AST_GETREGIONBOUNDS: Get the bounds of a Region -c - astGetRegionFrame: Get a copy of the Frame represent by a Region -f - AST_GETREGIONFRAME: Get a copy of the Frame represent by a Region -c - astGetRegionFrameSet: Get a copy of the Frameset encapsulated by a Region -f - AST_GETREGIONFRAMESET: Get a copy of the Frameset encapsulated by a Region -c - astGetRegionMesh: Get a mesh of points covering a Region -f - AST_GETREGIONMESH: Get a mesh of points covering a Region -c - astGetRegionPoints: Get the positions that define a Region -f - AST_GETREGIONPOINTS: Get the positions that define a Region -c - astGetUnc: Obtain uncertainty information from a Region -f - AST_GETUNC: Obtain uncertainty information from a Region -c - astMapRegion: Transform a Region into a new coordinate system -f - AST_MAPREGION: Transform a Region into a new coordinate system -c - astNegate: Toggle the value of the Negated attribute -f - AST_NEGATE: Toggle the value of the Negated attribute -c - astOverlap: Determines the nature of the overlap between two Regions -f - AST_OVERLAP: Determines the nature of the overlap between two Regions -c - astMask<X>: Mask a region of a data grid -f - AST_MASK<X>: Mask a region of a data grid -c - astSetUnc: Associate a new uncertainty with a Region -f - AST_SETUNC: Associate a new uncertainty with a Region -c - astShowMesh: Display a mesh of points on the surface of a Region -f - AST_SHOWMESH: Display a mesh of points on the surface of a Region - -* Copyright: -* Copyright (C) 1997-2006 Council for the Central Laboratory of the -* Research Councils -* Copyright (C) 2009 Science & Technology Facilities Council. -* All Rights Reserved. - -* Licence: -* This program is free software: you can redistribute it and/or -* modify it under the terms of the GNU Lesser General Public -* License as published by the Free Software Foundation, either -* version 3 of the License, or (at your option) any later -* version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU Lesser General Public License for more details. -* -* You should have received a copy of the GNU Lesser General -* License along with this program. If not, see -* <http://www.gnu.org/licenses/>. - -* Authors: -* DSB: David S. Berry (STARLINK) - -* History: -* 3-DEC-2003 (DSB): -* Original version. -* 12-MAY-2005 (DSB): -* Override astNormBox method. -* 12-AUG-2005 (DSB): -* Override ObsLat and ObsLon accessor methods. -* 14-FEB-2006 (DSB): -* Override astGetObjSize. -* 2-MAR-2006 (DSB): -* Changed AST_LONG_DOUBLE to HAVE_LONG_DOUBLE. -* 14-MAR-2006 (DSB): -* Added astGetRefFS. -* 28-MAY-2007 (DSB): -* - Added protected function astBndMesh. -* 14-JAN-2009 (DSB): -* Override the astIntersect method. -* 20-JAN-2009 (DSB): -* Change astPickAxes so that it returns a Region rather than a -* Frame if possible. This included adding method astRegBasePick. -* 9-FEB-2009 (DSB): -* Move PointList methods astGetEnclosure and astSetEnclosure to -* Region. -* 18-FEB-2009 (DSB): -* Remove methods astGetEnclosure and astSetEnclosure. -* 15-JUN-2009 (DSB): -* Modify MapRegion to use FrameSets properly. -* 18-JUN-2009 (DSB): -* Override ObsAlt accessor methods. -* 7-SEP-2009 (DSB): -* Fix astMask to avoid reading variance values from the data array. -* 8-SEP-2009 (DSB): -* Fix bugs in astOverlap that could result in wrong results if -* either region is unbounded. -* 4-JAN-2010 (DSB): -* Fix bug in GetRegionBounds (it was assumed implicitly that the base -* Frame had the same number of axes as the current Frame). -* 18-MAR-2011 (DSB): -* Added astGetRegionMesh public method. -* 22-MAR-2011 (DSB): -* Improve uniformity of points produced by astRegBaseGrid method. -* 29-APR-2011 (DSB): -* Prevent astFindFrame from matching a subclass template against a -* superclass target. -* 17-MAY-2011 (DSB): -* In RegBaseGrid, accept the final try even if it is not within 5% -* of the required meshsize. -* 27-APR-2012 (DSB): -* Store a negated copy of itself with each Region. Changing the Negated -* attribute of a Region causes the cached information to be reset, and -* re-calculating it can be an expensive operation. So instead of changing -* "Negatated" in "this", access the negated copy of "this" using the -* new protected method astGetNegation. -* 7-JUN-2012 (DSB): -* Added protected astRegSplit method to split a Region into disjoint -* component regions. -* 15-JUN-2012 (DSB): -* Guard against division by zero in RegBase Grid if "ipr" is zero. -* 7-NOV-2013 (DSB): -* Added method astGetRegionFrameSet. -* 3-FEB-2014 (DSB): -* Fix bug masking regions that have no overlap with the supplied array. -* 17-APR-2015 (DSB): -* Added Centre. -* 26-OCT-2016 (DSB): -* - Override the astAxNorm method. -* - Use astAxNorm to fix a bug in astGetRegionBounds for cases where -* the Region cross a longitude=0 singularity. -* 11-NOV-2016 (DSB): -* When loading a Region, use the dimensionality of the base Frame -* of the FrameSet (rather than the current Frame as it used to be) -* to define the number of axes required in the PointSet. -* 1-DEC-2016 (DSB): -* Changed MapRegion to remove any unnecessary base frame axes in -* the returned Region. -*class-- - -* Implementation Notes: -* - All sub-classes must over-ride the following abstract methods declared -* in this class: astRegBaseBox, astRegBaseMesh, astRegPins, astRegCentre. -* They must also extend the astTransform method. In addition they should -* usually extend astSimplify. - -*/ - -/* Module Macros. */ -/* ============== */ -/* Set the name of the class we are implementing. This indicates to - the header files that define class interfaces that they should make - "protected" symbols available. */ -#define astCLASS Region - -/* Value for Ident attribute of of an encapsulated FrameSet which - indicates that it is a dummy FrameSet (see astRegDummy). */ -#define DUMMY_FS "ASTREGION-DUMMY" - -/* -* Name: -* MAKE_CLEAR - -* Purpose: -* Define a function to clear an attribute value for a Region. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_CLEAR(attribute) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static void Clear<Attribute>( AstFrame *this ) -* -* that clears the value of a specified attribute for the encapsulated -* FrameSet within a Region (this). This function is intended to over-ride -* the astClear<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -*/ - -/* Define the macro. */ -#define MAKE_CLEAR(attribute) \ -static void Clear##attribute( AstFrame *this_frame, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Obtain a pointer to the encapsulated FrameSet and invoke its \ - astClear method. The protected astClear##attribute method is not used \ - because we want the current Frame of the FrameSet tp be re-mapped if \ - necessary. */ \ - astClear( this->frameset, #attribute ); \ -} - -/* -* Name: -* MAKE_CLEAR_AXIS - -* Purpose: -* Define a function to clear an attribute value for a Region axis. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_CLEAR_AXIS(attribute) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static void Clear<Attribute>( AstFrame *this, int axis ) -* -* that clears the value of a specified attribute for an axis of -* the encapsulated FrameSet within a Region (this). This function is -* intended to over-ride the astClear<Attribute> method inherited -* from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -*/ - -/* Define the macro. */ -#define MAKE_CLEAR_AXIS(attribute) \ -static void Clear##attribute( AstFrame *this_frame, int axis, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - char buf[100]; /* Buffer for attribute name */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Validate the axis index supplied. */ \ - (void) astValidateAxis( this, axis, 1, "astClear" #attribute ); \ -\ -/* We use the public astSetx method rather than the protected \ - astSet#attribute method so that the current Frame in the encapsulated \ - FrameSet will be re-mapped if necessary. Construct the attribute name. */ \ - sprintf( buf, "%s(%d)", #attribute, axis + 1 ); \ -\ -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \ - astClear method. The protected astClear#attribute method is notused \ - since we want the current Frame of the encapsulated FrameSet to be \ - remapped if required. */ \ - astClear( this->frameset, buf ); \ -} - -/* -* Name: -* MAKE_GET - -* Purpose: -* Define a function to get an attribute value for a Region. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_GET(attribute,type) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static <type> Get<Attribute>( AstFrame *this ) -* -* that gets the value of a specified attribute for the encapsulated -* FrameSet of a Region (this). This function is intended to over-ride -* the astGet<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -* type -* The C type of the attribute. -*/ - -/* Define the macro. */ -#define MAKE_GET(attribute,type) \ -static type Get##attribute( AstFrame *this_frame, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - type result; /* Value to return */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return (type) 0; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Obtain a pointer to the encapsulated FrameSet and invoke its \ - astGet<Attribute> method. */ \ - result = astGet##attribute( this->frameset ); \ -\ -/* If an error occurred, clear the result value. */ \ - if ( !astOK ) result = (type) 0; \ -\ -/* Return the result. */ \ - return result; \ -} - -/* -* Name: -* MAKE_GET_AXIS - -* Purpose: -* Define a function to get an attribute value for a Region axis. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_GET_AXIS(attribute,type) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static <type> Get<Attribute>( AstFrame *this, int axis ) -* -* that gets the value of a specified attribute for an axis of the -* encapsulated FrameSet within a Region (this). This function is intended -* to over-ride the astGet<Attribute> method inherited from the Frame -* class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -* type -* The C type of the attribute. -*/ - -/* Define the macro. */ -#define MAKE_GET_AXIS(attribute,type) \ -static type Get##attribute( AstFrame *this_frame, int axis, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - type result; /* Value to return */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return (type) 0; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Validate the axis index supplied. */ \ - (void) astValidateAxis( this, axis, 1, "astGet" #attribute ); \ -\ -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \ - astGet<Attribute> method. */ \ - result = astGet##attribute( this->frameset, axis ); \ -\ -/* If an error occurred, clear the result value. */ \ - if ( !astOK ) result = (type) 0; \ -\ -/* Return the result. */ \ - return result; \ -} - -/* -* Name: -* MAKE_SET_SYSTEM - -* Purpose: -* Define a function to set a System attribute value for a Region. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_SET_SYSTEM(attribute) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static void Set<Attribute>( AstFrame *this, AstSystemType value ) -* -* that sets the value of a specified attribute for the encapsulated -* FrameSet of a Region (this). This function is intended to over-ride the -* astSet<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -*/ - -/* Define the macro. */ -#define MAKE_SET_SYSTEM(attribute) \ -static void Set##attribute( AstFrame *this_frame, AstSystemType value, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - const char *text; /* Pointer to system string */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Convert the supplied value to a string using the astSystemString - method of the current Frame in the encapsulated FrameSet. */ \ - text = astSystemString( this->frameset, value ); \ -\ -/* Set the value by invoking the public astSetC method on the encapusulated \ - FrameSet. This ensures that the current Frame of the encapsulated \ - FrameSet is re-mapped if necessary. */ \ - astSetC( this->frameset, #attribute, text ); \ -} - -/* -* Name: -* MAKE_SET - -* Purpose: -* Define a function to set an attribute value for a Region. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_SET(attribute,type,x) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static void Set<Attribute>( AstFrame *this, <type> value ) -* -* that sets the value of a specified attribute for the encapsulated -* FrameSet of a Region (this). This function is intended to over-ride the -* astSet<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -* type -* The C type of the attribute. -* x -* The single character code for the astSetx function for the given C -* type. -*/ - -/* Define the macro. */ -#define MAKE_SET(attribute,type,x) \ -static void Set##attribute( AstFrame *this_frame, type value, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Set the value by invoking the public astSetx method on the encapusulated \ - FrameSet. This ensures that the current Frame of the encapsulated \ - FrameSet is re-mapped if necessary. */ \ - astSet##x( this->frameset, #attribute, value ); \ -} - -/* -* Name: -* MAKE_SET_AXIS - -* Purpose: -* Define a function to set an attribute value for a Region axis. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_SET_AXIS(attribute,type,x) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static void Set<Attribute>( AstFrame *this, int axis, <type> value ) -* -* that sets the value of a specified attribute for an axis of the -* encapsulated FrameSet within a Region (this). This function is intended -* to over-ride the astSet<Attribute> method inherited from the Frame -* class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -* type -* The C type of the attribute. -* x -* The single character code for the astSetx function for the given C -* type. -*/ - -/* Define the macro. */ -#define MAKE_SET_AXIS(attribute,type,x) \ -static void Set##attribute( AstFrame *this_frame, int axis, type value, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - char buf[100]; /* Buffer for attribute name */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Validate the axis index supplied. */ \ - (void) astValidateAxis( this, axis, 1, "astSet" #attribute ); \ -\ -/* We use the public astSetx method rather than the protected \ - astSet#attribute method so that the current Frame in the encapsulated \ - FrameSet will be re-mapped if necessary. Construct the attribute name. */ \ - sprintf( buf, "%s(%d)", #attribute, axis + 1 ); \ -\ -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \ - astSet<x> method. */ \ - astSet##x( this->frameset, buf, value ); \ -} - -/* -* Name: -* MAKE_TEST - -* Purpose: -* Define a function to test if an attribute value is set for a Region. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_TEST(attribute) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static int Test<Attribute>( AstFrame *this ) -* -* that returns a boolean result (0 or 1) to indicate if the value -* of a specified attribute for the encapsulated FrameSet within a -* Region (this) is set. This function is intended to over-ride the -* astTest<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -*/ - -/* Define the macro. */ -#define MAKE_TEST(attribute) \ -static int Test##attribute( AstFrame *this_frame, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to Region structure */ \ - int result; /* Result to return */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return 0; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \ - astTest<Attribute> method. */ \ - result = astTest##attribute( this->frameset ); \ -\ -/* If an error occurred, clear the result value. */ \ - if ( !astOK ) result = 0; \ -\ -/* Return the result. */ \ - return result; \ -} - -/* -* Name: -* MAKE_TEST_AXIS - -* Purpose: -* Define a function to test if an attribute value is set for a Region -* axis. - -* Type: -* Private macro. - -* Synopsis: -* #include "region.h" -* MAKE_TEST_AXIS(attribute) - -* Class Membership: -* Defined by the Region class. - -* Description: -* This macro expands to an implementation of a private member function -* of the form: -* -* static int Test<Attribute>( AstFrame *this, int axis ) -* -* that returns a boolean result (0 or 1) to indicate if the value -* of a specified attribute for an axis of the encapsulated FrameSet -* within a Region (this) is set. This function is intended to over-ride -* the astTest<Attribute> method inherited from the Frame class. - -* Parameters: -* attribute -* Name of the attribute, as it appears in the function name. -*/ - -/* Define the macro. */ -#define MAKE_TEST_AXIS(attribute) \ -static int Test##attribute( AstFrame *this_frame, int axis, int *status ) { \ -\ -/* Local Variables: */ \ - AstRegion *this; /* Pointer to the Region structure */ \ - int result; /* Value to return */ \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return 0; \ -\ -/* Obtain a pointer to the Region structure. */ \ - this = (AstRegion *) this_frame; \ -\ -/* Validate the axis index supplied. */ \ - (void) astValidateAxis( this, axis, 1, "astTest" #attribute ); \ -\ -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke its \ - astTest<Attribute> method. */ \ - result = astTest##attribute( this->frameset, axis ); \ -\ -/* If an error occurred, clear the result value. */ \ - if ( !astOK ) result = 0; \ -\ -/* Return the result. */ \ - return result; \ -} - -/* Header files. */ -/* ============= */ -/* Interface definitions. */ -/* ---------------------- */ - -#include "globals.h" /* Thread-safe global data access */ -#include "error.h" /* Error reporting facilities */ -#include "memory.h" /* Memory allocation facilities */ -#include "object.h" /* Base Object class */ -#include "mapping.h" /* Coordinate Mappings */ -#include "unitmap.h" /* Unit Mappings */ -#include "permmap.h" /* Coordinate permutation Mappings */ -#include "cmpmap.h" /* Compound Mappings */ -#include "frame.h" /* Parent Frame class */ -#include "frameset.h" /* Interconnected coordinate systems */ -#include "region.h" /* Interface definition for this class */ -#include "circle.h" /* Circular regions */ -#include "box.h" /* Box regions */ -#include "cmpregion.h" /* Compound regions */ -#include "ellipse.h" /* Elliptical regions */ -#include "pointset.h" /* Sets of points */ -#include "globals.h" /* Thread-safe global data access */ - -/* Error code definitions. */ -/* ----------------------- */ -#include "ast_err.h" /* AST error codes */ - -/* C header files. */ -/* --------------- */ -#include <ctype.h> -#include <limits.h> -#include <stdarg.h> -#include <stddef.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <math.h> - -/* Module Variables. */ -/* ================= */ - -/* Address of this static variable is used as a unique identifier for - member of this class. */ -static int class_check; - -/* Pointers to parent class methods which are extended by this class. */ -static int (* parent_getobjsize)( AstObject *, int * ); -static int (* parent_getusedefs)( AstObject *, int * ); - -#if defined(THREAD_SAFE) -static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * ); -#endif - -/* Define macros for accessing each item of thread specific global data. */ -#ifdef THREAD_SAFE - -/* Define how to initialise thread-specific globals. */ -#define GLOBAL_inits \ - globals->Class_Init = 0; \ - globals->GetAttrib_Buff[ 0 ] = 0; - -/* Create the function that initialises global data for this module. */ -astMAKE_INITGLOBALS(Region) - -/* Define macros for accessing each item of thread specific global data. */ -#define class_init astGLOBAL(Region,Class_Init) -#define class_vtab astGLOBAL(Region,Class_Vtab) -#define getattrib_buff astGLOBAL(Region,GetAttrib_Buff) - - - -/* If thread safety is not needed, declare and initialise globals at static - variables. */ -#else - -static char getattrib_buff[ 101 ]; - - -/* Define the class virtual function table and its initialisation flag - as static variables. */ -static AstRegionVtab class_vtab; /* Virtual function table */ -static int class_init = 0; /* Virtual function table initialised? */ - -#endif - -/* Prototypes for Private Member Functions. */ -/* ======================================== */ -#if HAVE_LONG_DOUBLE /* Not normally implemented */ -static int MaskLD( AstRegion *, AstMapping *, int, int, const int[], const int ubnd[], long double [], long double, int * ); -#endif -static int MaskB( AstRegion *, AstMapping *, int, int, const int[], const int[], signed char[], signed char, int * ); -static int MaskD( AstRegion *, AstMapping *, int, int, const int[], const int[], double[], double, int * ); -static int MaskF( AstRegion *, AstMapping *, int, int, const int[], const int[], float[], float, int * ); -static int MaskI( AstRegion *, AstMapping *, int, int, const int[], const int[], int[], int, int * ); -static int MaskL( AstRegion *, AstMapping *, int, int, const int[], const int[], long int[], long int, int * ); -static int MaskS( AstRegion *, AstMapping *, int, int, const int[], const int[], short int[], short int, int * ); -static int MaskUB( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned char[], unsigned char, int * ); -static int MaskUI( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned int[], unsigned int, int * ); -static int MaskUL( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned long int[], unsigned long int, int * ); -static int MaskUS( AstRegion *, AstMapping *, int, int, const int[], const int[], unsigned short int[], unsigned short int, int * ); - -static AstAxis *GetAxis( AstFrame *, int, int * ); -static AstFrame *GetRegionFrame( AstRegion *, int * ); -static AstFrameSet *GetRegionFrameSet( AstRegion *, int * ); -static AstFrame *PickAxes( AstFrame *, int, const int[], AstMapping **, int * ); -static AstFrame *RegFrame( AstRegion *, int * ); -static AstFrameSet *Conv( AstFrameSet *, AstFrameSet *, int * ); -static AstFrameSet *Convert( AstFrame *, AstFrame *, const char *, int * ); -static AstFrameSet *ConvertX( AstFrame *, AstFrame *, const char *, int * ); -static AstFrameSet *FindFrame( AstFrame *, AstFrame *, const char *, int * ); -static AstFrameSet *GetRegFS( AstRegion *, int * ); -static AstLineDef *LineDef( AstFrame *, const double[2], const double[2], int * ); -static AstMapping *RegMapping( AstRegion *, int * ); -static AstMapping *RemoveRegions( AstMapping *, int * ); -static AstMapping *Simplify( AstMapping *, int * ); -static AstObject *Cast( AstObject *, AstObject *, int * ); -static AstPointSet *BTransform( AstRegion *, AstPointSet *, int, AstPointSet *, int * ); -static AstPointSet *BndBaseMesh( AstRegion *, double *, double *, int * ); -static AstPointSet *BndMesh( AstRegion *, double *, double *, int * ); -static AstPointSet *GetSubMesh( int *, AstPointSet *, int * ); -static AstPointSet *RegBaseGrid( AstRegion *, int * ); -static AstPointSet *RegBaseMesh( AstRegion *, int * ); -static AstPointSet *RegGrid( AstRegion *, int * ); -static AstPointSet *RegMesh( AstRegion *, int * ); -static AstPointSet *RegTransform( AstRegion *, AstPointSet *, int, AstPointSet *, AstFrame **, int * ); -static AstPointSet *ResolvePoints( AstFrame *, const double [], const double [], AstPointSet *, AstPointSet *, int * ); -static AstRegion *MapRegion( AstRegion *, AstMapping *, AstFrame *, int * ); -static AstRegion *RegBasePick( AstRegion *, int, const int *, int * ); -static AstRegion **RegSplit( AstRegion *, int *, int * ); -static AstSystemType SystemCode( AstFrame *, const char *, int * ); -static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * ); -static const char *Abbrev( AstFrame *, int, const char *, const char *, const char *, int * ); -static const char *Format( AstFrame *, int, double, int * ); -static const char *SystemString( AstFrame *, AstSystemType, int * ); -static const int *GetPerm( AstFrame *, int * ); -static double *RegCentre( AstRegion *, double *, double **, int, int, int * ); -static double Angle( AstFrame *, const double[], const double[], const double[], int * ); -static double AxAngle( AstFrame *, const double[], const double[], int, int * ); -static double AxDistance( AstFrame *, int, double, double, int * ); -static double AxOffset( AstFrame *, int, double, double, int * ); -static double Distance( AstFrame *, const double[], const double[], int * ); -static double Centre( AstFrame *, int, double, double, int * ); -static double Gap( AstFrame *, int, double, int *, int * ); -static double Offset2( AstFrame *, const double[2], double, double, double[2], int * ); -static int Equal( AstObject *, AstObject *, int * ); -static int GetNaxes( AstFrame *, int * ); -static int GetObjSize( AstObject *, int * ); -static int GetUseDefs( AstObject *, int * ); -static int IsUnitFrame( AstFrame *, int * ); -static int LineContains( AstFrame *, AstLineDef *, int, double *, int * ); -static int LineCrossing( AstFrame *, AstLineDef *, AstLineDef *, double **, int * ); -static int Match( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * ); -static int Overlap( AstRegion *, AstRegion *, int * ); -static int OverlapX( AstRegion *, AstRegion *, int * ); -static int RegDummyFS( AstRegion *, int * ); -static int RegPins( AstRegion *, AstPointSet *, AstRegion *, int **, int * ); -static int SubFrame( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * ); -static int RegTrace( AstRegion *, int, double *, double **, int * ); -static int Unformat( AstFrame *, int, const char *, double *, int * ); -static int ValidateAxis( AstFrame *, int, int, const char *, int * ); -static void AxNorm( AstFrame *, int, int, int, double *, int * ); -static void CheckPerm( AstFrame *, const int *, const char *, int * ); -static void Copy( const AstObject *, AstObject *, int * ); -static void Delete( AstObject *, int * ); -static void Dump( AstObject *, AstChannel *, int * ); -static void GetRegionBounds( AstRegion *, double *, double *, int * ); -static void GetRegionBounds2( AstRegion *, double *, double *, int * ); -static void GetRegionMesh( AstRegion *, int, int, int, int *, double *, int * ); -static void GetRegionPoints( AstRegion *, int, int, int *, double *, int * ); -static void Intersect( AstFrame *, const double[2], const double[2], const double[2], const double[2], double[2], int * ); -static void LineOffset( AstFrame *, AstLineDef *, double, double, double[2], int * ); -static void MatchAxes( AstFrame *, AstFrame *, int *, int * ); -static void MatchAxesX( AstFrame *, AstFrame *, int *, int * ); -static void Negate( AstRegion *, int * ); -static void Norm( AstFrame *, double[], int * ); -static void NormBox( AstFrame *, double[], double[], AstMapping *, int * ); -static void Offset( AstFrame *, const double[], const double[], double, double[], int * ); -static void Overlay( AstFrame *, const int *, AstFrame *, int * ); -static void PermAxes( AstFrame *, const int[], int * ); -static void RegBaseBox( AstRegion *, double *, double *, int * ); -static void RegBaseBox2( AstRegion *, double *, double *, int * ); -static void RegClearAttrib( AstRegion *, const char *, char **, int * ); -static void RegOverlay( AstRegion *, AstRegion *, int, int * ); -static void RegSetAttrib( AstRegion *, const char *, char **, int * ); -static void ReportPoints( AstMapping *, int, AstPointSet *, AstPointSet *, int * ); -static void ResetCache( AstRegion *, int * ); -static void Resolve( AstFrame *, const double [], const double [], const double [], double [], double *, double *, int * ); -static void SetAxis( AstFrame *, int, AstAxis *, int * ); -static void SetRegFS( AstRegion *, AstFrame *, int * ); -static void ShowMesh( AstRegion *, int, const char *, int * ); -static void ValidateAxisSelection( AstFrame *, int, const int *, const char *, int * ); -static AstRegion *GetNegation( AstRegion *, int * ); - -static int GetBounded( AstRegion *, int * ); -static AstRegion *GetDefUnc( AstRegion *, int * ); - -static AstRegion *GetUncFrm( AstRegion *, int, int * ); -static AstRegion *GetUnc( AstRegion *, int, int * ); -static int TestUnc( AstRegion *, int * ); -static void ClearUnc( AstRegion *, int * ); -static void SetUnc( AstRegion *, AstRegion *, int * ); - -static const char *GetDomain( AstFrame *, int * ); -static int TestDomain( AstFrame *, int * ); -static void ClearDomain( AstFrame *, int * ); -static void SetDomain( AstFrame *, const char *, int * ); - -static const char *GetFormat( AstFrame *, int, int * ); -static int TestFormat( AstFrame *, int, int * ); -static void ClearFormat( AstFrame *, int, int * ); -static void SetFormat( AstFrame *, int, const char *, int * ); - -static const char *GetLabel( AstFrame *, int, int * ); -static int TestLabel( AstFrame *, int, int * ); -static void ClearLabel( AstFrame *, int, int * ); -static void SetLabel( AstFrame *, int, const char *, int * ); - -static const char *GetSymbol( AstFrame *, int, int * ); -static int TestSymbol( AstFrame *, int, int * ); -static void ClearSymbol( AstFrame *, int, int * ); -static void SetSymbol( AstFrame *, int, const char *, int * ); - -static const char *GetTitle( AstFrame *, int * ); -static void SetTitle( AstFrame *, const char *, int * ); -static void ClearTitle( AstFrame *, int * ); -static int TestTitle( AstFrame *, int * ); - -static const char *GetUnit( AstFrame *, int, int * ); -static int TestUnit( AstFrame *, int, int * ); -static void ClearUnit( AstFrame *, int, int * ); -static void SetUnit( AstFrame *, int, const char *, int * ); - -static int GetDigits( AstFrame *, int * ); -static int TestDigits( AstFrame *, int * ); -static void ClearDigits( AstFrame *, int * ); -static void SetDigits( AstFrame *, int, int * ); - -static int GetDirection( AstFrame *, int, int * ); -static int TestDirection( AstFrame *, int, int * ); -static void ClearDirection( AstFrame *, int, int * ); -static void SetDirection( AstFrame *, int, int, int * ); - -static int GetActiveUnit( AstFrame *, int * ); -static int TestActiveUnit( AstFrame *, int * ); -static void SetActiveUnit( AstFrame *, int, int * ); - -static int GetMatchEnd( AstFrame *, int * ); -static int TestMatchEnd( AstFrame *, int * ); -static void ClearMatchEnd( AstFrame *, int * ); -static void SetMatchEnd( AstFrame *, int, int * ); - -static int GetMaxAxes( AstFrame *, int * ); -static int TestMaxAxes( AstFrame *, int * ); -static void ClearMaxAxes( AstFrame *, int * ); -static void SetMaxAxes( AstFrame *, int, int * ); - -static int GetMinAxes( AstFrame *, int * ); -static int TestMinAxes( AstFrame *, int * ); -static void ClearMinAxes( AstFrame *, int * ); -static void SetMinAxes( AstFrame *, int, int * ); - -static int GetPermute( AstFrame *, int * ); -static int TestPermute( AstFrame *, int * ); -static void ClearPermute( AstFrame *, int * ); -static void SetPermute( AstFrame *, int, int * ); - -static int GetPreserveAxes( AstFrame *, int * ); -static int TestPreserveAxes( AstFrame *, int * ); -static void ClearPreserveAxes( AstFrame *, int * ); -static void SetPreserveAxes( AstFrame *, int, int * ); - -static double GetBottom( AstFrame *, int, int * ); -static int TestBottom( AstFrame *, int, int * ); -static void ClearBottom( AstFrame *, int, int * ); -static void SetBottom( AstFrame *, int, double, int * ); - -static double GetTop( AstFrame *, int, int * ); -static int TestTop( AstFrame *, int, int * ); -static void ClearTop( AstFrame *, int, int * ); -static void SetTop( AstFrame *, int, double, int * ); - -static double GetEpoch( AstFrame *, int * ); -static int TestEpoch( AstFrame *, int * ); -static void ClearEpoch( AstFrame *, int * ); -static void SetEpoch( AstFrame *, double, int * ); - -static double GetObsAlt( AstFrame *, int * ); -static int TestObsAlt( AstFrame *, int * ); -static void ClearObsAlt( AstFrame *, int * ); -static void SetObsAlt( AstFrame *, double, int * ); - -static double GetObsLat( AstFrame *, int * ); -static int TestObsLat( AstFrame *, int * ); -static void ClearObsLat( AstFrame *, int * ); -static void SetObsLat( AstFrame *, double, int * ); - -static double GetObsLon( AstFrame *, int * ); -static int TestObsLon( AstFrame *, int * ); -static void ClearObsLon( AstFrame *, int * ); -static void SetObsLon( AstFrame *, double, int * ); - -static AstSystemType GetSystem( AstFrame *, int * ); -static int TestSystem( AstFrame *, int * ); -static void ClearSystem( AstFrame *, int * ); -static void SetSystem( AstFrame *, AstSystemType, int * ); - -static AstSystemType GetAlignSystem( AstFrame *, int * ); -static int TestAlignSystem( AstFrame *, int * ); -static void ClearAlignSystem( AstFrame *, int * ); -static void SetAlignSystem( AstFrame *, AstSystemType, int * ); - -static const char *GetAttrib( AstObject *, const char *, int * ); -static int TestAttrib( AstObject *, const char *, int * ); -static void ClearAttrib( AstObject *, const char *, int * ); -static void SetAttrib( AstObject *, const char *, int * ); - -static int GetNegated( AstRegion *, int * ); -static int TestNegated( AstRegion *, int * ); -static void ClearNegated( AstRegion *, int * ); -static void SetNegated( AstRegion *, int, int * ); - -static int GetClosed( AstRegion *, int * ); -static int TestClosed( AstRegion *, int * ); -static void ClearClosed( AstRegion *, int * ); -static void SetClosed( AstRegion *, int, int * ); - -static int GetMeshSize( AstRegion *, int * ); -static int TestMeshSize( AstRegion *, int * ); -static void ClearMeshSize( AstRegion *, int * ); -static void SetMeshSize( AstRegion *, int, int * ); - -static double GetFillFactor( AstRegion *, int * ); -static int TestFillFactor( AstRegion *, int * ); -static void ClearFillFactor( AstRegion *, int * ); -static void SetFillFactor( AstRegion *, double, int * ); - -static int GetRegionFS( AstRegion *, int * ); -static int TestRegionFS( AstRegion *, int * ); -static void ClearRegionFS( AstRegion *, int * ); -static void SetRegionFS( AstRegion *, int, int * ); - -static int GetAdaptive( AstRegion *, int * ); -static int TestAdaptive( AstRegion *, int * ); -static void ClearAdaptive( AstRegion *, int * ); -static void SetAdaptive( AstRegion *, int, int * ); - -#if defined(THREAD_SAFE) -static int ManageLock( AstObject *, int, int, AstObject **, int * ); -#endif - - -/* Member functions. */ -/* ================= */ - -static const char *Abbrev( AstFrame *this_frame, int axis, const char *fmt, - const char *str1, const char *str2, int *status ) { -/* -* Name: -* Abbrev - -* Purpose: -* Abbreviate a formatted Region axis value by skipping leading fields. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* const char *Abbrev( AstFrame *this, int axis, const char *fmt, -* const char *str1, const char *str2, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astAbbrev -* method inherited from the Frame class). - -* Description: -* This function compares two Region axis values that have been -* formatted (using astFormat) and determines if they have any -* redundant leading fields (i.e. leading fields in common which -* can be suppressed when tabulating the values or plotting them on -* the axis of a graph). - -* Parameters: -* this -* Pointer to the Region -* axis -* The number of the Region axis for which the values have -* been formatted (axis numbering starts at zero for the first -* axis). -* fmt -* Pointer to a constant null-terminated string containing the -* format specification used to format the two values. -* str1 -* Pointer to a constant null-terminated string containing the -* first formatted value. -* str1 -* Pointer to a constant null-terminated string containing the -* second formatted value. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer into the "str2" string which locates the first -* character in the first field that differs between the two -* formatted values. -* -* If the two values have no leading fields in common, the returned -* value will point at the start of string "str2". If the two -* values are equal, it will point at the terminating null at the -* end of this string. - -* Notes: -* - This function assumes that the format specification used was -* the same when both values were formatted and that they both -* apply to the same Region axis. -* - A pointer to the start of "str2" will be returned if this -* function is invoked with the global error status set, or if it -* should fail for any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - const char *result; /* Pointer value to return */ - -/* Check the global error status. */ - if ( !astOK ) return str2; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astAbbrev" ); - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astAbbrev method to perform the processing. Annul the Frame - pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astAbbrev( fr, axis, fmt, str1, str2 ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result. */ - if ( !astOK ) result = str2; - -/* Return the result. */ - return result; -} - -static double Angle( AstFrame *this_frame, const double a[], - const double b[], const double c[], int *status ) { -/* -* Name: -* Angle - -* Purpose: -* Calculate the angle subtended by two points at a third point. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double Angle( AstFrame *this, const double a[], const double b[], -* const double c[], int *status ) - -* Class Membership: -* Region member function (over-rides the protected astAngle -* method inherited from the Frame class). - -* Description: -* This function finds the angle at point B between the line joining points -* A and B, and the line joining points C and B. These lines will in fact be -* geodesic curves appropriate to the Frame in use. For instance, in -* SkyFrame, they will be great circles. - -* Parameters: -* this -* Pointer to the Frame. -* a -* An array of double, with one element for each Frame axis -* (Naxes attribute) containing the coordinates of the first point. -* b -* An array of double, with one element for each Frame axis -* (Naxes attribute) containing the coordinates of the second point. -* c -* An array of double, with one element for each Frame axis -* (Naxes attribute) containing the coordinates of the third point. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* astAngle -* The angle in radians, from the line AB to the line CB. If the -* Frame is 2-dimensional, it will be in the range $\pm \pi$, -* and positive rotation is in the same sense as rotation from -* the positive direction of axis 2 to the positive direction of -* axis 1. If the Frame has more than 2 axes, a positive value will -* always be returned in the range zero to $\pi$. - -* Notes: -* - A value of AST__BAD will also be returned if points A and B are -* co-incident, or if points B and C are co-incident. -* - A value of AST__BAD will also be returned if this function is -* invoked with the AST error status set, or if it should fail for -* any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke this - Frame's astAngle method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astAngle( fr, a, b, c ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static double AxAngle( AstFrame *this_frame, const double a[], const double b[], int axis, int *status ) { -/* -* Name: -* AxAngle - -* Purpose: -* Returns the angle from an axis, to a line through two points. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double AxAngle( AstFrame *this, const double a[], const double b[], int axis, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astAxAngle -* method inherited from the Frame class). - -* Description: -* This function finds the angle, as seen from point A, between the positive -* direction of a specified axis, and the geodesic curve joining point -* A to point B. - -* Parameters: -* this -* Pointer to the Frame. -* a -* An array of double, with one element for each Frame axis -* (Naxes attribute) containing the coordinates of the first point. -* b -* An array of double, with one element for each Frame axis -* (Naxes attribute) containing the coordinates of the second point. -* axis -* The number of the Frame axis from which the angle is to be -* measured (one-based) -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The angle in radians, from the positive direction of the -* specified axis, to the line AB. If the Frame is 2-dimensional, -* it will be in the range $\pm \pi$, and positive rotation is in -* the same sense as rotation from the positive direction of axis 2 -* to the positive direction of axis 1. If the Frame has more than 2 -* axes, a positive value will always be returned in the range zero -* to $\pi$. - -* Notes: -* - The geodesic curve used by this function is the path of -* shortest distance between two points, as defined by the -* astDistance function. -* - This function will return "bad" coordinate values (AST__BAD) -* if any of the input coordinates has this value, or if the require -* position angle is undefined. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis - 1, 1, "astAxAngle" ); - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astAxAngle method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astAxAngle( fr, a, b, axis ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static double AxDistance( AstFrame *this_frame, int axis, double v1, double v2, int *status ) { -/* -* Name: -* AxDistance - -* Purpose: -* Find the distance between two axis values. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double AxDistance( AstFrame *this, int axis, double v1, double v2, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astAxDistance -* method inherited from the Frame class). - -* Description: -* This function returns a signed value representing the axis increment -* from axis value v1 to axis value v2. -* -* For a simple Frame, this is a trivial operation returning the -* difference between the two axis values. But for other derived classes -* of Frame (such as a SkyFrame) this is not the case. - -* Parameters: -* this -* Pointer to the Frame. -* axis -* The index of the axis to which the supplied values refer. The -* first axis has index 1. -* v1 -* The first axis value. -* v2 -* The second axis value. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The distance between the two axis values. - -* Notes: -* - This function will return a "bad" result value (AST__BAD) if -* any of the input vaues has this value. -* - A "bad" value will also be returned if this function is -* invoked with the AST error status set, or if it should fail for -* any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis - 1, 1, "astAxDistance" ); - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astAxDistance method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astAxDistance( fr, axis, v1, v2 ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static void AxNorm( AstFrame *this_frame, int axis, int oper, int nval, - double *values, int *status ){ -/* -* Name: -* AxNorm - -* Purpose: -* Normalise an array of axis values. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void AxNorm( AstFrame *this, int axis, int oper, int nval, -* double *values, int *status ) - -* Class Membership: -* FrameSet member function (over-rides the protected astAxNorm -* method inherited from the Frame class). - -* Description: -* This function modifies a supplied array of axis values so that -* they are normalised in the manner indicated by parameter "oper". -* -* No normalisation is possible for a simple Frame and so the supplied -* values are returned unchanged. However, this may not be the case for -* specialised sub-classes of Frame. For instance, a SkyFrame has a -* discontinuity at zero longitude and so a longitude value can be -* expressed in the range [-Pi,+PI] or the range [0,2*PI]. - -* Parameters: -* this -* Pointer to the Frame. -* axis -* The index of the axis to which the supplied values refer. The -* first axis has index 1. -* oper -* Indicates the type of normalisation to be applied. If zero is -* supplied, the normalisation will be the same as that performed by -* function astNorm. If 1 is supplied, the normalisation will be -* chosen automatically so that the resulting list has the smallest -* range. -* nval -* The number of points in the values array. -* values -* On entry, the axis values to be normalised. Modified on exit to -* hold the normalised values. -* status -* Pointer to the inherited status variable. - -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis - 1, 1, "astAxNorm" ); - -/* Obtain a pointer to the Region's encapsulated Frame and invoke - the astAxNorm method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astAxNorm( fr, axis, oper, nval, values ); - fr = astAnnul( fr ); -} - -static double AxOffset( AstFrame *this_frame, int axis, double v1, double dist, int *status ) { -/* -* Name: -* AxOffset - -* Purpose: -* Add an increment onto a supplied axis value. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double AxOffset( AstFrame *this, int axis, double v1, double dist, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astAxOffset -* method inherited from the Frame class). - -* Description: -* This function returns an axis value formed by adding a signed axis -* increment onto a supplied axis value. -* -* For a simple Frame, this is a trivial operation returning the -* sum of the two supplied values. But for other derived classes -* of Frame (such as a SkyFrame) this is not the case. - -* Parameters: -* this -* Pointer to the Frame. -* axis -* The index of the axis to which the supplied values refer. The -* first axis has index 1. -* v1 -* The original axis value. -* dist -* The axis increment to add to the original axis value. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The incremented axis value. - -* Notes: -* - This function will return a "bad" result value (AST__BAD) if -* any of the input vaues has this value. -* - A "bad" value will also be returned if this function is -* invoked with the AST error status set, or if it should fail for -* any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis - 1, 1, "astAxOffset" ); - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astAxOffset method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astAxOffset( fr, axis, v1, dist ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static AstPointSet *BndBaseMesh( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*+ -* Name: -* astBndBaseMesh - -* Purpose: -* Return a PointSet containing points spread around part of the boundary -* of a Region, in the base Frame. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astBndBaseMesh( AstRegion *this, double *lbnd, double *ubnd ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a set of points on the -* boundary of the intersection between the supplied Region and the -* supplied (current Frame) box. The mesh points refer to the base -* Frame. If the boundary of the supplied Region does not intersect the -* supplied box, then a PointSet containing a single bad point is -* returned. - -* Parameters: -* this -* Pointer to the Region. -* lbnd -* Pointer to an array holding the lower limits of the axis values -* within the required box. Defined in the current Frame of the Region. -* ubnd -* Pointer to an array holding the upper limits of the axis values -* within the required box. Defined in the current Frame of the Region. - -* Returned Value: -* Pointer to the PointSet holding the base Frame mesh. The axis values -* in this PointSet will have associated accuracies derived from the -* uncertainties which were supplied when the Region was created. -* -* If the Region does not intersect the supplied box, the returned -* PointSet will contain a single point with a value of AST__BAD on -* every axis. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables: */ - AstBox *box; - AstCmpRegion *cmpreg; - AstPointSet *result; - double **ptr; - int ic; - int nc; - -/* Check the local error status. */ - if ( !astOK ) return NULL; - -/* Form a Box describing the required box. */ - box = astBox( this, 1, lbnd, ubnd, NULL, "", status ); - -/* Check there is partial overlap between the Regions.*/ - if( astOverlap( this, box ) > 3 ) { - -/* Form a CmpRegion representing the intersection between the supplied - Region and the above box. */ - cmpreg = astCmpRegion( this, box, AST__AND, "", status ); - -/* Get the boundary mesh. */ - result = astRegBaseMesh( cmpreg ); - -/* Free resources. */ - cmpreg = astAnnul( cmpreg ); - -/* If the boundary of the supplied Region does not intersect the box, - return a PointSet containing a single bad position. */ - } else { - nc = astGetNin( this->frameset ); - result = astPointSet( 1, nc, "", status ); - ptr = astGetPoints( result ); - if( ptr ) { - for( ic = 0; ic < nc; ic++ ) ptr[ ic ][ 0 ] = AST__BAD; - } - } - -/* Free resources. */ - box = astAnnul( box ); - -/* Return NULL if an error occurred. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the required pointer. */ - return result; -} - -static AstPointSet *BndMesh( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*+ -* Name: -* astBndMesh - -* Purpose: -* Return a PointSet containing points spread around part of the boundary -* of a Region, in the current Frame. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astBndMesh( AstRegion *this, double *lbnd, double *ubnd ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a set of points on the -* boundary of the intersection between the supplied Region and the -* supplied box. The points refer to the current Frame of the -* encapsulated FrameSet. If the boundary of the supplied Region does -* not intersect the supplied box, then a PointSet containing a single -* bad point is returned. - -* Parameters: -* this -* Pointer to the Region. -* lbnd -* Pointer to an array holding the lower limits of the axis values -* within the required box. Defined in the current Frame of the Region. -* ubnd -* Pointer to an array holding the upper limits of the axis values -* within the required box. Defined in the current base Frame of the -* Region. - -* Returned Value: -* Pointer to the PointSet. The axis values in this PointSet will have -* associated accuracies derived from the uncertainties which were -* supplied when the Region was created. -* -* If the Region does not intersect the supplied box, the returned -* PointSet will contain a single point with a value of AST__BAD on -* every axis. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables: */ - AstMapping *map; - AstPointSet *ps1; - AstPointSet *result; - -/* Initialise */ - result = NULL; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* Get the current->base Mapping from the Region. */ - map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE ); - -/* Use astBndBaseMesh to get a mesh of base Frame points within this base - Frame bounding box. */ - ps1 = astBndBaseMesh( this, lbnd, ubnd ); - -/* Transform it into the current Frame. */ - if( ps1 ) result = astTransform( map, ps1, 0, NULL ); - -/* Free resources. */ - map = astAnnul( map ); - ps1 = astAnnul( ps1 ); - -/* Return NULL if an error occurred. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the required pointer. */ - return result; -} - -static AstPointSet *BTransform( AstRegion *this, AstPointSet *in, - int forward, AstPointSet *out, int *status ) { -/* -*+ -* Name: -* astBTransform - -* Purpose: -* Use a Region to transform a set of points in the base Frame. - -* Type: -* Protected virtual function. - -* Synopsis: -* #include "circle.h" -* AstPointSet *astBTransform( AstRegion *this, AstPointSet *in, - int forward, AstPointSet *out ) - -* Class Membership: -* Region member function - -* Description: -* This function takes a Region and a set of points within the base -* Frame of the Region, and transforms the points by setting axis values -* to AST__BAD for all points which are outside the region. Points inside -* the region are copied unchanged from input to output. - -* Parameters: -* this -* Pointer to the Region. -* in -* Pointer to the PointSet holding the input coordinate data. -* forward -* A non-zero value indicates that the forward coordinate transformation -* should be applied, while a zero value requests the inverse -* transformation. -* out -* Pointer to a PointSet which will hold the transformed (output) -* coordinate values. A NULL value may also be given, in which case a -* new PointSet will be created by this function. - -* Returned Value: -* Pointer to the output (possibly new) PointSet. - -* Notes: -* - This is identical to the astTransform method for a Region except -* that the supplied and returned points refer to the base Frame of -* the Region, rather than the current Frame. -*- -*/ - -/* Local Variables: */ - AstPointSet *result; /* Pointer to output PointSet */ - int old; /* Origial value of "nomap" flag */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Save the current value of the "nomap" flag for this Region,and then - set it. Doing this tells the astRegMapping function (called by - astRegTransform) to assume a unit map connects base and current Frame. */ - old = this->nomap; - this->nomap = 1; - -/* Invoke the usual astTransform method. The above setting of the "nomap" - flag will cause the astTransform method to treat the base Frame as the - current Frame. */ - result = astTransform( this, in, forward, out ); - -/* Reset the "nomap" flag. */ - this->nomap = old; - -/* Return a pointer to the output PointSet. */ - return result; -} - -static AstObject *Cast( AstObject *this_object, AstObject *obj, int *status ) { -/* -* Name: -* Cast - -* Purpose: -* Cast an Object into an instance of a sub-class. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstObject *Cast( AstObject *this, AstObject *obj, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astCast -* method inherited from the Frame class). - -* Description: -* This function returns a deep copy of an ancestral component of the -* supplied object. The required class of the ancestral component is -* specified by another object. Specifically, if "this" and "new" are -* of the same class, a copy of "this" is returned. If "this" is an -* instance of a subclass of "obj", then a copy of the component -* of "this" that matches the class of "obj" is returned. Otherwise, -* a NULL pointer is returned without error. - -* Parameters: -* this -* Pointer to the Object to be cast. -* obj -* Pointer to an Object that defines the class of the returned Object. -* The returned Object will be of the same class as "obj". - -* Returned Value: -* A pointer to the new Object. NULL if "this" is not a sub-class of -* "obj", or if an error occurs. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables; */ - AstFrame *cfrm; - AstObject *new; - astDECLARE_GLOBALS - int generation_gap; - -/* Initialise */ - new = NULL; - -/* Check inherited status */ - if( !astOK ) return new; - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(NULL); - -/* See how many steps up the class inheritance ladder it is from "obj" - to this class (Region). A positive value is returned if Region is - a sub-class of "obj". A negative value is returned if "obj" is a - sub-class of Region. Zero is returned if "obj" is a Region. - AST__COUSIN is returned if "obj" is not on the same line of descent - as Region. */ - generation_gap = astClassCompare( (AstObjectVtab *) &class_vtab, - astVTAB( obj ) ); - -/* If "obj" is a Region or a sub-class of Region, we can cast by - truncating the vtab for "this" so that it matches the vtab of "obJ", - and then taking a deep copy of "this". */ - if( generation_gap <= 0 && generation_gap != AST__COUSIN ) { - new = astCastCopy( this_object, obj ); - -/* If "obj" is not a Region or a sub-class of Region (e.g. a Frame or - some sub-class of Frame), we attempt to cast the current Frame of the - encapsulated FrameSet into the class indicated by "obj". */ - } else { - cfrm = astGetFrame( ((AstRegion *) this_object)->frameset, AST__CURRENT ); - new = astCast( cfrm, obj ); - cfrm = astAnnul( cfrm ); - } - -/* Return the new pointer. */ - return new; -} - -static double Centre( AstFrame *this_frame, int axis, double value, double gap, int *status ) { -/* -* Name: -* Centre - -* Purpose: -* Find a "nice" central value for tabulating Frame axis values. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double Centre( AstFrame *this_frame, int axis, double value, -* double gap, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astCentre method -* inherited from the Frame class). - -* Description: -* This function returns an axis value which produces a nice formatted -* value suitable for a major tick mark on a plot axis, close to the -* supplied axis value. - -* Parameters: -* this -* Pointer to the Frame. -* axis -* The number of the axis (zero-based) for which a central value -* is to be found. -* value -* An arbitrary axis value in the section that is being plotted. -* gap -* The gap size. - -* Returned Value: -* The nice central axis value. - -* Notes: -* - A value of zero is returned if the supplied gap size is zero. -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return 0.0; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astCentre" ); - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astCentre method to obtain the required value. Annul the - Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astCentre( fr, axis, value, gap ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result. */ - if ( !astOK ) result = 0.0; - -/* Return the result. */ - return result; -} - -static void CheckPerm( AstFrame *this_frame, const int *perm, const char *method, int *status ) { -/* -* Name: -* CheckPerm - -* Purpose: -* Check that an array contains a valid permutation. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void CheckPerm( AstFrame *this, const int *perm, const char *method, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astCheckPerm -* method inherited from the Frame class). - -* Description: -* This function checks the validity of a permutation array that -* will be used to permute the order of a Frame's axes. If the -* permutation specified by the array is not valid, an error is -* reported and the global error status is set. Otherwise, the -* function returns without further action. - -* Parameters: -* this -* Pointer to the Frame. -* perm -* Pointer to an array of integers with the same number of -* elements as there are axes in the Frame. For each axis, the -* corresponding integer gives the (zero based) axis index to be -* used to identify the information for that axis (using the -* un-permuted axis numbering). To be valid, the integers in -* this array should therefore all lie in the range zero to -* (naxes-1) inclusive, where "naxes" is the number of Frame -* axes, and each value should occur exactly once. -* method -* Pointer to a constant null-terminated character string -* containing the name of the method that invoked this function -* to validate a permutation array. This method name is used -* solely for constructing error messages. -* status -* Pointer to the inherited status variable. - -* Notes: -* - Error messages issued by this function refer to the external -* (public) numbering system used for axes (which is one-based), -* whereas zero-based axis indices are used internally. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke this - Frame's astCheckPerm method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astCheckPerm( fr, perm, method ); - fr = astAnnul( fr ); - -} - -static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* ClearAttrib - -* Purpose: -* Clear an attribute value for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void ClearAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* Region member function (over-rides the astClearAttrib protected -* method inherited from the Frame class). - -* Description: -* This function clears the value of a specified attribute for a -* Region, so that the default value will subsequently be used. - -* Parameters: -* this -* Pointer to the Region. -* attrib -* Pointer to a null terminated string specifying the attribute -* name. This should be in lower case with no surrounding white -* space. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* Check the attribute name and clear the appropriate attribute. */ - -/* We first handle attributes that apply to the Region as a whole - (rather than to the encapsulated FrameSet). */ - -/* Negated */ -/* ------- */ - if ( !strcmp( attrib, "negated" ) ) { - astClearNegated( this ); - -/* Closed */ -/* ------ */ - } else if ( !strcmp( attrib, "closed" ) ) { - astClearClosed( this ); - -/* FillFactor */ -/* ---------- */ - } else if ( !strcmp( attrib, "fillfactor" ) ) { - astClearFillFactor( this ); - -/* MeshSize */ -/* -------- */ - } else if ( !strcmp( attrib, "meshsize" ) ) { - astClearMeshSize( this ); - -/* Adaptive */ -/* -------- */ - } else if ( !strcmp( attrib, "adaptive" ) ) { - astClearAdaptive( this ); - - -/* We now check for atttributes of superclasses which apply to the Region - as a whole. We do not want to pass these on to the encapsulated FrameSet. */ - -/* ID. */ -/* --- */ - } else if ( !strcmp( attrib, "id" ) ) { - astClearID( this ); - -/* Ident. */ -/* ------ */ - } else if ( !strcmp( attrib, "ident" ) ) { - astClearIdent( this ); - -/* Invert. */ -/* ------- */ - } else if ( !strcmp( attrib, "invert" ) ) { - astClearInvert( this ); - -/* Report. */ -/* ------- */ - } else if ( !strcmp( attrib, "report" ) ) { - astClearReport( this ); - - -/* If the name was not recognised, test if it matches any of the - read-only attributes of this class (including those of all superclasses). - If it does, then report an error. */ - } else if ( !strcmp( attrib, "class" ) || - !strcmp( attrib, "nin" ) || - !strcmp( attrib, "nobject" ) || - !strcmp( attrib, "nout" ) || - !strcmp( attrib, "bounded" ) || - !strcmp( attrib, "refcount" ) || - !strcmp( attrib, "tranforward" ) || - !strcmp( attrib, "traninverse" ) ) { - astError( AST__NOWRT, "astClear: Invalid attempt to clear the \"%s\" " - "value for a %s.", status, attrib, astGetClass( this ) ); - astError( AST__NOWRT, "This is a read-only attribute." , status); - -/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for - further interpretation. Do not pass on FrameSet attributes since we - pretend to the outside world that the encapsulated FrameSet is actually a - Frame. */ - } else if ( strcmp( attrib, "base" ) && - strcmp( attrib, "current" ) && - strcmp( attrib, "nframe" ) ) { - -/* If the Region is to adapt to coordinate system chanmges, use the public - astClear method so that the current Frame in the encapsulated FrameSet will - be re-mapped if the attribute changes require it. */ - if( astGetAdaptive( this ) ) { - astClear( this->frameset, attrib ); - -/* If the Region is not to adapt to coordinate system chanmges, use the - astRegSetAttrib method which assigns the attribute setting to both - current and base Frames in the FrameSet without causing any remapping to - be performed. */ - } else { - astRegClearAttrib( this, attrib, NULL ); - } - } -} - -static AstFrameSet *Conv( AstFrameSet *from, AstFrameSet *to, int *status ){ -/* -* Name: -* Conv - -* Purpose: -* Find Mapping between Frames - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstFrameSet *Conv( AstFrameSet *from, AstFrameSet *to, int *status ); - -* Class Membership: -* Region member function - -* Description: -* This function provides a convenient interface for astConvert. -* It is like astConvert except it does not alter the base Frames of -* the supplied FrameSets and does not require a Domain list. - -* Parameters: -* from -* Pointer to the source FrameSet. -* to -* Pointer to the source FrameSet. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The conversion FrameSet (see astConvert). - -*/ - -/* Local Variables: */ - AstFrameSet *result; /* FrameSet to return */ - int from_base; /* Index of original base Frame in "from" */ - int to_base; /* Index of original base Frame in "to" */ - -/* Check the global error status. */ - if( !astOK ) return NULL; - -/* Note the indices of the base Frames in the FrameSets. */ - to_base = astGetBase( to ); - from_base = astGetBase( from ); - -/* Invoke astConvert. */ - result = astConvert( from, to, "" ); - -/* Re-instate original base Frames. */ - astSetBase( to, to_base ); - astSetBase( from, from_base ); - -/* Return the result. */ - return result; -} - -static AstFrameSet *Convert( AstFrame *from, AstFrame *to, - const char *domainlist, int *status ) { -/* -* Name: -* Convert - -* Purpose: -* Determine how to convert between two coordinate systems. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstFrameSet *Convert( AstFrame *from, AstFrame *to, -* const char *domainlist, int *status ) - -* Class Membership: -* Region member function (over-rides the public astConvert -* method inherited fromm the Frame class). - -* Description: -* This function compares two Regions and determines whether it -* is possible to convert between the coordinate systems which -* their current Frames represent. If conversion is possible, it -* returns a FrameSet which describes the conversion and which may -* be used (as a Mapping) to transform coordinate values in either -* direction. - -* Parameters: -* from -* Pointer to a Region whose current Frame represents the -* "source" coordinate system. Note that the Base attribute of -* the Region may be modified by this function. -* to -* Pointer to a Region whose current Frame represents the -* "destination" coordinate system. Note that the Base -* attribute of the Region may be modified by this function. -* domainlist -* Pointer to a null-terminated character string containing a -* comma-separated list of Frame domains. This may be used to -* define a priority order for the different intermediate -* coordinate systems that might be used to perform the -* conversion. -* -* The function will first try to obtain a conversion by making -* use only of intermediate Frames whose Domain attribute -* matches the first domain in this list. If this fails, the -* second domain in the list will be used, and so on, until -* conversion is achieved. A blank domain (e.g. two consecutive -* commas) indicates that all Frames should be considered, -* regardless of their Domain attributes. The list is -* case-insensitive and all white space is ignored. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* If the requested coordinate conversion is possible, the -* function returns a pointer to a FrameSet which describes the -* conversion. Otherwise, a null Object pointer (AST__NULL) is -* returned without error. -* -* If a FrameSet is returned, it will contain two Frames. Frame -* number 1 (its base Frame) will describe the source coordinate -* system, corresponding to the "from" parameter. Frame number 2 -* (its current Frame) will describe the destination coordinate -* system, corresponding to the "to" parameter. The Mapping -* which inter-relates these Frames will perform the required -* conversion between the two coordinate systems. - -* Notes: -* - The returned FrameSet will not contain any Regions. If one or -* more of the supplied Frames are in fact Regions, the corresponding -* Frames in any returned FrameSet will described the encapsulated -* Frame, without any region information. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrameSet *result; /* Returned FrameSet */ - -/* Check the inherited status. */ - if ( !astOK ) return NULL; - -/* If the "from" pointer is a Region, get a pointer to the current Frame of - the encapsulated FrameSet and use it instead of the supplied pointer. */ - if( astIsARegion( from ) ) { - from = astGetFrame( ((AstRegion *) from)->frameset, AST__CURRENT ); - } else { - from = astClone( from ); - } - -/* If the "to" pointer is a Region, get a pointer to the current Frame of - the encapsulated FrameSet and use it instead of the supplied pointer. */ - if( astIsARegion( to ) ) { - to = astGetFrame( ((AstRegion *) to)->frameset, AST__CURRENT ); - } else { - to = astClone( to ); - } - -/* Now invoke astConvert on the above Frames. */ - result = astConvert( from, to, domainlist ); - -/* Annul the pointers used above. */ - from = astAnnul( from ); - to = astAnnul( to ); - -/* Return the result */ - return result; -} - -static AstFrameSet *ConvertX( AstFrame *to, AstFrame *from, - const char *domainlist, int *status ) { -/* -* Name: -* ConvertX - -* Purpose: -* Determine how to convert between two coordinate systems. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstFrameSet *astConvertX( AstFrame *to, AstFrame *from, -* const char *domainlist ) - -* Class Membership: -* Region member function (over-rides the protected astConvertX -* method inherited from the Frame class). - -* Description: -* This function performs the processing for the public astConvert -* method and has exactly the same interface except that the order -* of the first two arguments is swapped. This is a trick to allow -* the astConvert method to be over-ridden by derived classes on -* the basis of the class of either of its first two arguments. -* -* See the astConvert method for details of the interface. -*- -*/ - -/* Local Variables: */ - AstFrameSet *result; /* Returned FrameSet */ - -/* Check the inherited status. */ - if ( !astOK ) return NULL; - -/* If the "to" pointer is a Region, get a pointer to the current Frame of - the encapsulated FrameSet and use it instead of the supplied pointer. */ - if( astIsARegion( to ) ) { - to = astGetFrame( ((AstRegion *) to)->frameset, AST__CURRENT ); - } else { - to = astClone( to ); - } - -/* If the "from" pointer is a Region, get a pointer to the current Frame of - the encapsulated FrameSet and use it instead of the supplied pointer. */ - if( astIsARegion( from ) ) { - from = astGetFrame( ((AstRegion *) from)->frameset, AST__CURRENT ); - } else { - from = astClone( from ); - } - -/* Now invoke astConvertX on the above Frames. */ - result = astConvertX( to, from, domainlist ); - -/* Annul the pointers used above. */ - from = astAnnul( from ); - to = astAnnul( to ); - -/* Return the result */ - return result; -} - -static double Distance( AstFrame *this_frame, const double point1[], - const double point2[], int *status ) { -/* -* Name: -* Distance - -* Purpose: -* Calculate the distance between two points. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double Distance( AstFrame *this, const double point1[], -* const double point2[], int *status ) - -* Class Membership: -* Region member function (over-rides the protected astDistance -* method inherited from the Frame class). - -* Description: -* This function finds the distance between two points whose -* Region coordinates are given. The distance calculated is that -* along the geodesic curve that joins the two points. - -* Parameters: -* this -* Pointer to the Region. -* point1 -* An array of double, with one element for each Region axis -* containing the coordinates of the first point. -* point2 -* An array of double, with one element for each Region axis -* containing the coordinates of the second point. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The distance between the two points. - -* Notes: -* - This function will return a "bad" result value (AST__BAD) if -* any of the input coordinates has this value. -* - A "bad" value will also be returned if this function is -* invoked with the AST error status set or if it should fail for -* any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astDistance method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astDistance( fr, point1, point2 ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static int Equal( AstObject *this_object, AstObject *that_object, int *status ) { -/* -* Name: -* Equal - -* Purpose: -* Test if two Objects are equivalent. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int Equal( AstObject *this_object, AstObject *that_object, int *status ) - -* Class Membership: -* Region member function (over-rides the astEqual protected -* method inherited from the Frame class). - -* Description: -* This function returns a boolean result (0 or 1) to indicate whether -* two Regions are equivalent. - -* Parameters: -* this -* Pointer to the first Region. -* that -* Pointer to the second Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* One if the Regions are equivalent, zero otherwise. - -* Notes: -* - The Regions are equivalent if they are of the same class, have -* equal PointSets, have equal base Frames, have equal current Frames, -* and if the Mapping between base Frames is a UnitMap. In addition, the -* Negated attribute must have the same value in both Regions, as must -* the Closed attribute. -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstFrame *bf1; - AstFrame *bf2; - AstFrame *cf1; - AstFrame *cf2; - AstMapping *m1; - AstMapping *m2; - AstRegion *that; - AstRegion *this; - const char *class1; - const char *class2; - int result; - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Check that the two objects have the same class. */ - class1 = astGetClass( this_object ); - class2 = astGetClass( that_object ); - if( astOK && !strcmp( class1, class2 ) ) { - -/* Obtain pointers to the two Region structures. */ - this = (AstRegion *) this_object; - that = (AstRegion *) that_object; - -/* Test their PointSets for equality. */ - if( astEqual( this->points, that->points ) ){ - -/* Test their base Frames for equality. */ - bf1 = astGetFrame( this->frameset, AST__BASE ); - bf2 = astGetFrame( that->frameset, AST__BASE ); - if( astEqual( bf1, bf2 ) ){ - -/* Test their current Frames for equality. */ - cf1 = astGetFrame( this->frameset, AST__CURRENT ); - cf2 = astGetFrame( that->frameset, AST__CURRENT ); - if( astEqual( cf1, cf2 ) ){ - -/* Get the two Mappings and check that they are equal */ - m1 = astGetMapping( this->frameset, AST__BASE, AST__CURRENT ); - m2 = astGetMapping( that->frameset, AST__BASE, AST__CURRENT ); - if( astEqual( m1, m2 ) ) { - -/* Test the Negated and Closed flags are equal */ - if( astGetNegated( this ) == astGetNegated( that ) && - astGetClosed( this ) == astGetClosed( that ) ) { - result = 1; - } - } - -/* Free resources. */ - m1 = astAnnul( m1 ); - m2 = astAnnul( m2 ); - } - - cf1 = astAnnul( cf1 ); - cf2 = astAnnul( cf2 ); - } - - bf1 = astAnnul( bf1 ); - bf2 = astAnnul( bf2 ); - } - } - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result, */ - return result; -} - -static void ClearUnc( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astClearUnc - -* Purpose: -* Erase any uncertainty information in a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astClearUnc( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function erases all uncertainty information, whether default -* or not, from a Region. - -* Parameters: -* this -* Pointer to the Region. - -*- -*/ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Annul any user-supplied uncertainty. Also indicate that cached - information may now be out of date. */ - if( this->unc ) { - this->unc = astAnnul( this->unc ); - astResetCache( this ); - } - -/* Annul any default uncertainty. */ - if( this->defunc ) this->defunc = astAnnul( this->defunc ); - -} - -static AstFrameSet *FindFrame( AstFrame *target_frame, AstFrame *template, - const char *domainlist, int *status ) { -/* -* Name: -* FindFrame - -* Purpose: -* Find a coordinate system with specified characteristics. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstFrameSet *FindFrame( AstFrame *target, AstFrame *template, -* const char *domainlist, int *status ) - -* Class Membership: -* Region member function (over-rides the astFindFrame method -* inherited from the Frame class). - -* Description: -* This function uses a "template" Frame to search a Region to -* identify a coordinate system which has a specified set of -* characteristics. If a suitable coordinate system can be found, -* the function returns a pointer to a FrameSet which describes the -* required coordinate system and how to convert coordinates to and -* from it. - -* Parameters: -* target -* Pointer to the target Region. -* template -* Pointer to the template Frame, which should be an instance of -* the type of Frame you wish to find. -* domainlist -* Pointer to a null-terminated character string containing a -* comma-separated list of Frame domains. This may be used to -* establish a priority order for the different types of -* coordinate system that might be found. -* -* The function will first try to find a suitable coordinate -* system whose Domain attribute equals the first domain in this -* list. If this fails, the second domain in the list will be -* used, and so on, until a result is obtained. A blank domain -* (e.g. two consecutive commas) indicates that any coordinate -* system is acceptable (subject to the template) regardless of -* its domain. -* -* This list is case-insensitive and all white space is ignored. -* If you do not wish to restrict the domain in this way, you -* should supply an empty string. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* If the search is successful, the function returns a pointer to a -* FrameSet which contains the Frame found and a description of how -* to convert to (and from) the coordinate system it -* represents. Otherwise, a null Object pointer (AST__NULL) is -* returned without error. -* -* If a FrameSet is returned, it will contain two Frames. Frame -* number 1 (its base Frame) represents the target coordinate -* system and will be the same as the target. Frame number 2 (its -* current Frame) will be a Frame representing the coordinate system -* which the function found. The Mapping which inter-relates these two -* Frames will describe how to convert between their respective coordinate -* systems. Note, the Frames in this FrameSet will not be Regions - -* that is, they will be simple Frames or other derived classes. - -* Notes: -* - A null Object pointer (AST__NULL) will be returned if this -* function is invoked with the AST error status set, or if it -* should fail for any reason. -*/ - -/* Local Variables: */ - AstFrameSet *result; /* Pointer to result FrameSet */ - AstFrame *fr; /* Pointer to encapsulated Frame */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Invoke the astFindFrame method on the current Frame of the - encapsulated FrameSet within the target Region. */ - fr = astGetFrame( ((AstRegion *) target_frame)->frameset, AST__CURRENT ); - result = astFindFrame( fr, template, domainlist ); - fr = astAnnul( fr ); - -/* Return the result. */ - return result; -} - -static const char *Format( AstFrame *this_frame, int axis, double value, int *status ) { -/* -* Name: -* Format - -* Purpose: -* Format a coordinate value for a Region axis. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* const char *Format( AstFrame *this, int axis, double value, int *status ) - -* Class Membership: -* Region member function (over-rides the astFormat method -* inherited from the Frame class). - -* Description: -* This function returns a pointer to a string containing the -* formatted (character) version of a coordinate value for a -* Region axis. The formatting applied is that specified by a -* previous invocation of the astSetFormat method. A suitable -* default format is applied if necessary. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The number of the axis (zero-based) for which formatting is -* to be performed. -* value -* The coordinate value to be formatted. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer to a null-terminated string containing the formatted -* value. - -* Notes: -* - The returned string pointer may point at memory allocated -* within the Region object, or at static memory. The contents of -* the string may be over-written or the pointer may become invalid -* following a further invocation of the same function or deletion -* of the Region. A copy of the string should therefore be made -* if necessary. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - const char *result; /* Pointer value to return */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astFormat" ); - -/* Obtain a pointer to the Region's current Frame and invoke the - astFormat method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astFormat( fr, axis, value ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = NULL; - -/* Return the result. */ - return result; -} - -static double Gap( AstFrame *this_frame, int axis, double gap, int *ntick, int *status ) { -/* -* Name: -* Gap - -* Purpose: -* Find a "nice" gap for tabulating Region axis values. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double Gap( AstFrame *this, int axis, double gap, int *ntick, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astGap method -* inherited from the Frame class). - -* Description: -* This function returns a gap size which produces a nicely spaced -* series of formatted values for a Region axis, the returned gap -* size being as close as possible to the supplied target gap -* size. It also returns a convenient number of divisions into -* which the gap can be divided. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The number of the axis (zero-based) for which a gap is to be found. -* gap -* The target gap size. -* ntick -* Address of an int in which to return a convenient number of -* divisions into which the gap can be divided. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The nice gap size. - -* Notes: -* - A value of zero is returned if the target gap size is zero. -* - A negative gap size is returned if the supplied gap size is negative. -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Gap value to return */ - -/* Check the global error status. */ - if ( !astOK ) return 0.0; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astGap" ); - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astGap method to obtain the required gap value. Annul the - Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astGap( fr, axis, gap, ntick ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result. */ - if ( !astOK ) result = 0.0; - -/* Return the result. */ - return result; -} - -static int GetObjSize( AstObject *this_object, int *status ) { -/* -* Name: -* GetObjSize - -* Purpose: -* Return the in-memory size of an Object. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int GetObjSize( AstObject *this, int *status ) - -* Class Membership: -* Region member function (over-rides the astGetObjSize protected -* method inherited from the parent class). - -* Description: -* This function returns the in-memory size of the supplied Region, -* in bytes. - -* Parameters: -* this -* Pointer to the Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The Object size, in bytes. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to Region structure */ - int result; /* Result value to return */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointers to the Region structure. */ - this = (AstRegion *) this_object; - -/* Invoke the GetObjSize method inherited from the parent class, and then - add on any components of the class structure defined by thsi class - which are stored in dynamically allocated memory. */ - result = (*parent_getobjsize)( this_object, status ); - - result += astGetObjSize( this->frameset ); - result += astGetObjSize( this->points ); - result += astGetObjSize( this->basemesh ); - result += astGetObjSize( this->basegrid ); - result += astGetObjSize( this->unc ); - result += astGetObjSize( this->negation ); - result += astGetObjSize( this->defunc ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result, */ - return result; -} - -static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* GetAttrib - -* Purpose: -* Get the value of a specified attribute for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* const char *GetAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astGetAttrib -* method inherited from the Frame class). - -* Description: -* This function returns a pointer to the value of a specified -* attribute for a Region, formatted as a character string. - -* Parameters: -* this -* Pointer to the Region. -* attrib -* Pointer to a null-terminated string containing the name of -* the attribute whose value is required. This name should be in -* lower case, with all white space removed. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* - Pointer to a null-terminated string containing the attribute -* value. - -* Notes: -* - The returned string pointer may point at memory allocated -* within the Region, or at static memory. The contents of the -* string may be over-written or the pointer may become invalid -* following a further invocation of the same function or any -* modification of the Region. A copy of the string should -* therefore be made if necessary. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ - AstRegion *this; /* Pointer to the Region structure */ - const char *result; /* Pointer value to return */ - double dval; /* Floating point attribute value */ - int ival; /* Integer attribute value */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(this_object); - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* Compare "attrib" with each recognised attribute name in turn, - obtaining the value of the required attribute. If necessary, write - the value into "getattrib_buff" as a null-terminated string in an appropriate - format. Set "result" to point at the result string. */ - -/* We first handle attributes that apply to the Region as a whole - (rather than to the encapsulated FrameSet). */ - -/* Negated */ -/* ------- */ - if ( !strcmp( attrib, "negated" ) ) { - ival = astGetNegated( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Closed */ -/* ------ */ - } else if ( !strcmp( attrib, "closed" ) ) { - ival = astGetClosed( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Adaptive */ -/* -------- */ - } else if ( !strcmp( attrib, "adaptive" ) ) { - ival = astGetAdaptive( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* FillFactor */ -/* ---------- */ - } else if ( !strcmp( attrib, "fillfactor" ) ) { - dval = astGetFillFactor( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval ); - result = getattrib_buff; - } - -/* MeshSize */ -/* -------- */ - } else if ( !strcmp( attrib, "meshsize" ) ) { - ival = astGetMeshSize( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Bounded */ -/* ------- */ - } else if ( !strcmp( attrib, "bounded" ) ) { - ival = astGetBounded( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Now get the values of attributes inherited from parent classes. We do - this to avoid the request being passed on to the encapsulated FrameSet - below. */ - -/* Class. */ -/* ------ */ - } else if ( !strcmp( attrib, "class" ) ) { - result = astGetClass( this ); - -/* ID. */ -/* --- */ - } else if ( !strcmp( attrib, "id" ) ) { - result = astGetID( this ); - -/* Ident. */ -/* ------ */ - } else if ( !strcmp( attrib, "ident" ) ) { - result = astGetIdent( this ); - -/* Invert. */ -/* ------- */ - } else if ( !strcmp( attrib, "invert" ) ) { - ival = astGetInvert( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Nin. */ -/* ---- */ - } else if ( !strcmp( attrib, "nin" ) ) { - ival = astGetNin( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Nobject. */ -/* -------- */ - } else if ( !strcmp( attrib, "nobject" ) ) { - ival = astGetNobject( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Nout. */ -/* ----- */ - } else if ( !strcmp( attrib, "nout" ) ) { - ival = astGetNout( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* RefCount. */ -/* --------- */ - } else if ( !strcmp( attrib, "refcount" ) ) { - ival = astGetRefCount( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Report. */ -/* ------- */ - } else if ( !strcmp( attrib, "report" ) ) { - ival = astGetReport( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* TranForward. */ -/* ------------ */ - } else if ( !strcmp( attrib, "tranforward" ) ) { - ival = astGetTranForward( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* TranInverse. */ -/* ------------ */ - } else if ( !strcmp( attrib, "traninverse" ) ) { - ival = astGetTranInverse( this ); - if ( astOK ) { - (void) sprintf( getattrib_buff, "%d", ival ); - result = getattrib_buff; - } - -/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for - further interpretation. Do not pass on FrameSet attributes since we - pretend to the outside world that the encapsulated FrameSet is actually a - Frame. */ - } else if ( strcmp( attrib, "base" ) && - strcmp( attrib, "current" ) && - strcmp( attrib, "nframe" ) ) { - result = astGetAttrib( this->frameset, attrib ); - } - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = NULL; - -/* Return the result. */ - return result; -} - -static int GetBounded( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astGetBounded - -* Purpose: -* Is the Region bounded? - -* Type: -* Protected function. - -* Synopsis: -* int astGetBounded( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a flag indicating if the Region is bounded. -* The implementation provided by the base Region class is suitable -* for Region sub-classes representing the inside of a single closed -* curve (e.g. Circle, Ellipse, Box, etc). Other sub-classes (such as -* CmpRegion, PointList, etc ) may need to provide their own -* implementations. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Non-zero if the Region is bounded. Zero otherwise. - -*- -*/ - -/* For Regions which are defined by one or more closed curves such as Circles, - Boxes, etc, the Region is bounded so long as it has not been negated. - Classes for which this is not true should over-ride this implementation. */ - return !astGetNegated( this ); -} - -static AstAxis *GetAxis( AstFrame *this_frame, int axis, int *status ) { -/* -* Name: -* GetAxis - -* Purpose: -* Obtain a pointer to a specified Axis from a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstAxis *GetAxis( AstFrame *this, int axis, int *status ) - -* Class Membership: -* Region member function (over-rides the astGetAxis method -* inherited from the Frame class). - -* Description: -* This function returns a pointer to the Axis object associated -* with one of the axes of the current Frame of a Region. This -* object describes the quantity which is represented along that -* axis. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The number of the axis (zero-based) for which an Axis pointer -* is required. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer to the requested Axis object. - -* Notes: -* - The reference count of the requested Axis object will be -* incremented by one to reflect the additional pointer returned by -* this function. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstAxis *result; /* Pointer to Axis */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astGetAxis" ); - -/* Obtain a pointer to the Region's encapsulated FrameSet and invoke - this FrameSet's astGetAxis method to obtain the required Axis - pointer. */ - result = astGetAxis( this->frameset, axis ); - -/* If an error occurred, annul the result. */ - if ( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -static AstRegion *GetDefUnc( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astGetDefUnc - -* Purpose: -* Obtain a pointer to the default uncertainty Region for a given Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *astGetDefUnc( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a pointer to a Region which represents the -* default uncertainty associated with a position on the boundary of the -* given Region. The returned Region refers to the base Frame within the -* FrameSet encapsulated by the supplied Region. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* A pointer to the Region. This should be annulled (using astAnnul) -* when no longer needed. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstFrame *bfrm; /* Base Frame of supplied Region */ - AstRegion *result; /* Returned pointer */ - double *lbnd; /* Ptr. to array holding axis lower bounds */ - double *ubnd; /* Ptr. to array holding axis upper bounds */ - double c; /* Central axis value */ - double hw; /* Half width of uncertainty interval */ - int i; /* Axis index */ - int nax; /* Number of base Frame axes */ - -/* Initialise */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the base Frame in the supplied Region. */ - bfrm = astGetFrame( this->frameset, AST__BASE ); - -/* Get the number of base Frame axes. */ - nax = astGetNaxes( bfrm ); - -/* Get the base frame bounding box of the supplied Region. The astRegBaseBox - assumes the supplied Region has not been inverted. But if the Region - contains other Regions (e.g. a Prism or CmpRegion, etc) then this - assumption needs to be propagated to the component Regions, which - astRegBaseBox does not do. For this reason we use astRegBaseBox2 - instead. */ - lbnd = astMalloc( sizeof( double)*(size_t) nax ); - ubnd = astMalloc( sizeof( double)*(size_t) nax ); - astRegBaseBox2( this, lbnd, ubnd ); - -/* Create a Box covering 1.0E-6 of this bounding box, centred on the - centre of the box. */ - if( astOK ) { - for( i = 0; i < nax; i++ ) { - if( ubnd[ i ] != DBL_MAX && lbnd[ i ] != -DBL_MAX ) { - hw = fabs( 0.5E-6*( ubnd[ i ] - lbnd[ i ] ) ); - c = 0.5*( ubnd[ i ] + lbnd[ i ] ); - if( hw == 0.0 ) hw = c*0.5E-6; - ubnd[ i ] = c + hw; - lbnd[ i ] = c - hw; - } else { - ubnd[ i ] = 0.0; - lbnd[ i ] = 0.0; - } - } - result = (AstRegion *) astBox( bfrm, 1, lbnd, ubnd, NULL, "", status ); - } - -/* Free resources. */ - lbnd = astFree( lbnd ); - ubnd = astFree( ubnd ); - bfrm = astAnnul( bfrm ); - -/* Return NULL if an error occurred. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the required pointer. */ - return result; -} - -static AstRegion *GetNegation( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astGetNegation - -* Purpose: -* Obtain a pointer to a negated copy of the supplied Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *GetNegation( AstRegion *this, int *status ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a pointer to a Region which is a negated -* copy of "this". The copy is cached in the Region structure for -* future use. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* A pointer to the Region. This should be annulled (using astAnnul) -* when no longer needed. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* If the Region struture does not contain a pointer to a negated copy of - itself, create one now. */ - if( ! this->negation ) { - this->negation = astCopy( this ); - astNegate( this->negation ); - } - -/* Return a clone of the negation pointer. */ - return astClone( this->negation ); -} - -static AstFrameSet *GetRegFS( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astGetRegFS - -* Purpose: -* Obtain a pointer to the FrameSet encapsulated within a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstFrameSet *astGetRegFS( AstRegion *this ) - -* Class Membership: -* Region virtual function - -* Description: -* This function returns a pointer to the FrameSet encapsulated by the -* Region. This is a clone, not a deep copy, of the pointer stored -* in the Region. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* A pointer to the FrameSet. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Return the required pointer. */ - return astClone( this->frameset ); -} - -static AstPointSet *GetSubMesh( int *mask, AstPointSet *in, int *status ) { -/* -* Name: -* GetSubMesh - -* Purpose: -* Extract a selection of points from a PointSet. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstPointSet *GetSubMesh( int *mask, AstPointSet *in, int *status ) - -* Class Membership: -* Region member function - -* Description: -* This function creates a new PointSet holding points selected from a -* supplied PointSet. An integer mask is supplied to indicate which -* points should be selected. - -* Parameters: -* mask -* Pointer to a mask array, Its size should be equal to the number -* of points in the supplied PointSet. Each corresponding point will -* be copied if the mask value is zero. -* in -* Pointer to the PointSet holding the input positions. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the output PointSet. - -* Notes: -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstPointSet *result; /* Pointer to output PointSet */ - double **ptr_in; /* Pointers to input axis values */ - double **ptr_out; /* Pointers to output axis values */ - double *pin; /* Pointer to next input axis value */ - double *pout; /* Pointer to next output axis value */ - int *m; /* Pointer to next mask element */ - int ic; /* Axis index */ - int ip; /* Point index */ - int nc; /* Number of axes in both PointSets */ - int npin; /* Number of points in input PointSet */ - int npout; /* Number of points in output PointSet */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get the length of the mask. */ - npin = astGetNpoint( in ); - -/* Count the number of zeros in the mask. */ - npout = 0; - m = mask; - for( ip = 0; ip < npin; ip++ ) { - if( *(m++) == 0 ) npout++; - } - -/* Create the output PointSet and get pointers to its data arrays. */ - nc = astGetNcoord( in ); - result = astPointSet( npout, nc, "", status ); - ptr_in = astGetPoints( in ); - ptr_out = astGetPoints( result ); - -/* Check pointers can be dereferenced safely. */ - if( astOK ) { - -/* Copy the required axis values from the input to the output. */ - for( ic = 0; ic < nc; ic++ ) { - pin = ptr_in[ ic ]; - pout = ptr_out[ ic ]; - m = mask; - for( ip = 0; ip < npin; ip++, pin++, m++ ) { - if( *m == 0 ) *(pout++) = *pin; - } - } - } - -/* Return a pointer to the output PointSet. */ - return result; - -} - -static AstRegion *GetUnc( AstRegion *this, int def, int *status ){ -/* -*++ -* Name: -c astGetUnc -f AST_GETUNC - -* Purpose: -* Obtain uncertainty information from a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c AstRegion *astGetUnc( AstRegion *this, int def ) -f RESULT = AST_GETUNC( THIS, DEF, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function returns a Region which represents the uncertainty -* associated with positions within the supplied Region. See -c astSetUnc -f AST_SETUNC -* for more information about Region uncertainties and their use. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c def -f DEF = LOGICAL (Given) -* Controls what is returned if no uncertainty information has been -* associated explicitly with the supplied Region. If -c a non-zero value -f .TRUE. -* is supplied, then the default uncertainty Region used internally -* within AST is returned (see "Applicability" below). If -c zero is supplied, then NULL -f .FALSE. is supplied, then AST__NULL -* will be returned (without error). -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astGetUnc() -f AST_GETUNC = INTEGER -* A pointer to a Region describing the uncertainty in the supplied -* Region. - -* Applicability: -* CmpRegion -* The default uncertainty for a CmpRegion is taken from one of the -* two component Regions. If the first component Region has a -* non-default uncertainty, then it is used as the default uncertainty -* for the parent CmpRegion. Otherwise, if the second component Region -* has a non-default uncertainty, then it is used as the default -* uncertainty for the parent CmpRegion. If neither of the -* component Regions has non-default uncertainty, then the default -* uncertainty for the CmpRegion is 1.0E-6 of the bounding box of -* the CmpRegion. -* Prism -* The default uncertainty for a Prism is formed by combining the -* uncertainties from the two component Regions. If a component -* Region does not have a non-default uncertainty, then its default -* uncertainty will be used to form the default uncertainty of the -* parent Prism. -* Region -* For other classes of Region, the default uncertainty is 1.0E-6 -* of the bounding box of the Region. If the bounding box has zero -* width on any axis, then the uncertainty will be 1.0E-6 of the -* axis value. - -* Notes: -* - If uncertainty information is associated with a Region, and the -* coordinate system described by the Region is subsequently changed -* (e.g. by changing the value of its System attribute, or using the -c astMapRegion -f AST_MAPREGION -* function), then the uncertainty information returned by this function -* will be modified so that it refers to the coordinate system currently -* described by the supplied Region. -f - A null Object pointer (AST__NULL) will be returned if this -f function is invoked with STATUS set to an error value, or if it -c - A null Object pointer (NULL) will be returned if this -c function is invoked with the AST error status set, or if it -* should fail for any reason. - -*-- -*/ - -/* Local Variables: */ - AstRegion *result; /* Pointer to returned uncertainty Region */ - AstRegion *unc; /* Pointer to original uncertainty Region */ - -/* Initialise */ - result = NULL; - -/* Check inherited status */ - if( !astOK ) return result; - -/* Check that we have an uncertainty Region to return (either assigned or - default). */ - if( def || astTestUnc( this ) ) { - -/* Obtain the uncertainty Region and take a copy so that we can modify it - without affecting the supplied Region. */ - unc = astGetUncFrm( this, AST__CURRENT ); - result = astCopy( unc ); - unc = astAnnul( unc ); - -/* In its current context, the uncertainty region is known to refer to - the Frame of the supplied Region and so its RegionFS attribute will be - set to zero, indicating that the uncertainty FrameSet need not be - dumped. However, outside of AST this information cannot be implied, so - clear the RegionFS attribute so that the returned pointer will include - Frame information if it is dumped to a Channel. */ - astClearRegionFS( result ); - - } - -/* Return the result. */ - return result; - -} - -static AstRegion *GetUncFrm( AstRegion *this, int ifrm, int *status ) { -/* -*+ -* Name: -* astGetUncFrm - -* Purpose: -* Obtain a pointer to the uncertainty Region for a given Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *astGetUncFrm( AstRegion *this, int ifrm ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a pointer to a Region which represents the -* uncertainty associated with a position on the boundary of the given -* Region. The returned Region can refer to the either the base or -* the current Frame within the FrameSet encapsulated by the supplied -* Region as specified by the "ifrm" parameter. If the returned Region is -* re-centred at some point on the boundary of the supplied Region, then -* the re-centred Region will represent the region in which the true -* boundary position could be. - -* Parameters: -* this -* Pointer to the Region. -* ifrm -* The index of a Frame within the FrameSet encapsulated by "this". -* The returned Region will refer to the requested Frame. It should -* be either AST__CURRENT or AST__BASE. - -* Returned Value: -* A pointer to the Region. This should be annulled (using astAnnul) -* when no longer needed. - -* Notes: -* - A default uncertainty Region will be created if the supplied Region -* does not have an uncertainty Region. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstFrame *frm; /* Current Frame from supplied Region */ - AstMapping *map; /* Supplied to uncertainty Mapping */ - AstRegion *result; /* Returned pointer */ - AstRegion *unc; /* Base frame uncertainty Region to use */ - -/* Initialise */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* If the Region has an explicitly assigned base-frame uncertainty Region, - use it. */ - if( this->unc ) { - unc = this->unc; - -/* If not, use the default base-frame uncertainty Region, creating it if - necessary. */ - } else { - if( !this->defunc ) this->defunc = astGetDefUnc( this ); - unc = this->defunc; - } - -/* If the uncertainty Region is the base Frame is required, just return a - clone of the uncertainty Region pointer. The Frame represented by an - uncertainty Region will always (barring bugs!) be the base Frame of - its parent Region. */ - if( ifrm == AST__BASE ) { - result = astClone( unc ); - -/* If the uncertainty Region is the current Frame is required... */ - } else { - -/* Get a Mapping from the Frame represented by the uncertainty Region - (the Region base Frame) to the Region current Frame. */ - map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT ); - -/* If this is a UnitMap, the uncertainty Region is already in the correct - Frame, so just return the stored pointer. */ - if( astIsAUnitMap( map ) ) { - result = astClone( unc ); - -/* Otherwise, use this Mapping to map the uncertainty Region into the current - Frame. */ - } else { - frm = astGetFrame( this->frameset, AST__CURRENT ); - result = astMapRegion( unc, map, frm ); - -/* Free resources. */ - frm = astAnnul( frm ); - } - - map = astAnnul( map ); - } - -/* Return NULL if an error occurred. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the required pointer. */ - return result; -} - -static int GetUseDefs( AstObject *this_object, int *status ) { -/* -* Name: -* GetUseDefs - -* Purpose: -* Get the value of the UseDefs attribute for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int GetUseDefs( AstObject *this_object, int *status ) { - -* Class Membership: -* Region member function (over-rides the protected astGetUseDefs -* method inherited from the Frame class). - -* Description: -* This function returns the value of the UseDefs attribute for a -* Region. supplying a suitable default. - -* Parameters: -* this -* Pointer to the Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* - The USeDefs value. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - int result; /* Value to return */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* If the UseDefs value for the Region has been set explicitly, use the - Get method inherited from the parent Frame class to get its value. */ - if( astTestUseDefs( this ) ) { - result = (*parent_getusedefs)( this_object, status ); - -/* Otherwise, supply a default value equal to the UseDefs value of the - encapsulated Frame. */ - } else { - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astGetUseDefs( fr ); - fr = astAnnul( fr ); - } - -/* Return the result. */ - return result; -} - -static int TestUnc( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astTestUnc - -* Purpose: -* Does the Region contain non-default uncertainty information? - -* Type: -* Protected function. - -* Synopsis: -* int astTestUnc( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a flag indicating if the uncertainty Region in -* the supplied Region was supplied explicit (i.e. is not a default -* uncertainty Region). - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Non-zero if the uncertainty Region was supplied explicitly. -* Zero otherwise. - -* Notes: -* - Classes of Region that encapsulate two or more other Regions -* inherit their default uncertainty from the encapsulated Regions. -* Non-default uncertainty in the component Regions does not imply -* that the parent Region has non-default uncertainty. -*- -*/ - -/* Check the global error status. */ - if ( !astOK ) return 0; - - return ( this->unc != NULL ); -} - -static AstFrame *RegFrame( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astRegFrame - -* Purpose: -* Obtain a pointer to the current Frame for a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstFrame *astRegFrame( AstRegion *this ) - -* Class Membership: -* Region virtual function - -* Description: -* This function returns a pointer to the current Frame in the encapsulated -* FrameSet. This is a clone, not a deep copy, of the pointer stored -* in the FrameSet. For a deep copy, use astGetRegionFrame. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* A pointer to the Frame. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Return the required pointer. */ - return astGetFrame( this->frameset, AST__CURRENT ); -} - -static AstMapping *RegMapping( AstRegion *this, int *status ) { -/* -*+ -* Name: -* astRegMapping - -* Purpose: -* Obtain a pointer to the simplified base->current Mapping for a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstMapping *astRegMapping( AstRegion *this ) - -* Class Membership: -* Region member function - -* Description: -* This function returns a pointer to the Mapping from the base to the -* current Frame int he encapsulated FrameSet. The returned Mapping is -* simplified before being returned. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* A pointer to the Mapping. - -* Notes: -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstMapping *map; /* Unsimplified Mapping */ - AstMapping *result; /* Simplified Mapping */ - -/* Initialise */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* If the "nomap" flag is set in the Region structure, re return a - UnitMap. */ - if( this->nomap ) { - result = (AstMapping *) astUnitMap( astGetNin( this->frameset ), "", status ); - -/* Otherwise use the Mapping from the Region's FrameSet. */ - } else { - -/* Get the Mapping */ - map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT ); - -/* Simplify it. */ - result = astSimplify( map ); - -/* Annul the pointer to the unsimplified Mapping */ - map = astAnnul( map ); - } - -/* Return the required pointer. */ - return result; -} - -static int GetNaxes( AstFrame *this_frame, int *status ) { -/* -* Name: -* GetNaxes - -* Purpose: -* Determine how many axes a Region has. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int GetNaxes( AstFrame *this, int *status ) - -* Class Membership: -* Region member function (over-rides the astGetNaxes method -* inherited from the Frame class). - -* Description: -* This function returns the number of axes for a Region. This is equal -* to the number of axes in its current Frame. - -* Parameters: -* this -* Pointer to the Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The number of Region axes (zero or more). - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - int result; /* Result to be returned */ - -/* Check the global error status. */ - if ( !astOK ) return 0; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - -/* Obtain the number of axes in this Frame. */ - result = astGetNaxes( fr ); - -/* Annul the current Frame pointer. */ - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result. */ - return result; -} - -static const int *GetPerm( AstFrame *this_frame, int *status ) { -/* -* Name: -* GetPerm - -* Purpose: -* Access the axis permutation array for the current Frame of a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* const int *GetPerm( AstFrame *this, int *status ) - -* Class Membership: -* Region member function (over-rides the astGetPerm protected -* method inherited from the Frame class). - -* Description: -* This function returns a pointer to the axis permutation array -* for the current Frame of a Region. This array constitutes a -* lookup-table that converts between an axis number supplied -* externally and the corresponding index in the Frame's internal -* axis arrays. - -* Parameters: -* this -* Pointer to the Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the current Frame's axis permutation array (a -* constant array of int). Each element of this contains the -* (zero-based) internal axis index to be used in place of the -* external index which is used to address the permutation -* array. If the current Frame has zero axes, this pointer will be -* NULL. - -* Notes: -* - The pointer returned by this function gives direct access to -* data internal to the Frame object. It remains valid only so long -* as the Frame exists. The permutation array contents may be -* modified by other functions which operate on the Frame and this -* may render the returned pointer invalid. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to Region structure */ - const int *result; /* Result pointer value */ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame and then obtain a - pointer to its axis permutation array. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astGetPerm( fr ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = NULL; - -/* Return the result. */ - return result; -} - -static AstFrame *GetRegionFrame( AstRegion *this, int *status ) { -/* -*++ -* Name: -c astGetRegionFrame -f AST_GETREGIONFRAME - -* Purpose: -* Obtain a pointer to the encapsulated Frame within a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c AstFrame *astGetRegionFrame( AstRegion *this ) -f RESULT = AST_GETREGIONFRAME( THIS, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function returns a pointer to the Frame represented by a -* Region. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astGetRegionFrame() -f AST_GETREGIONFRAME = INTEGER -* A pointer to a deep copy of the Frame represented by the Region. -* Using this pointer to modify the Frame will have no effect on -* the Region. To modify the Region, use the Region pointer directly. - -* Notes: -* - A null Object pointer (AST__NULL) will be returned if this -c function is invoked with the AST error status set, or if it -f function is invoked with STATUS set to an error value, or if it -* should fail for any reason. -*-- -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstFrame *result; /* Pointer value to return */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the current Frame of the encapsulated FrameSet. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - -/* Take a deep copy of it, and then annul the original pointer. */ - result = astCopy( fr ); - fr = astAnnul( fr ); - -/* If not OK, annul the returned pointer. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -static AstFrameSet *GetRegionFrameSet( AstRegion *this, int *status ) { -/* -*++ -* Name: -c astGetRegionFrameSet -f AST_GETREGIONFRAMESET - -* Purpose: -* Obtain a pointer to the encapsulated FrameSet within a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c AstFrame *astGetRegionFrameSet( AstRegion *this ) -f RESULT = AST_GETREGIONFRAMESET( THIS, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function returns a pointer to the FrameSet encapsulated by a -* Region. The base Frame is the Frame in which the box was originally -* defined, and the current Frame is the Frame into which the Region -* is currently mapped (i.e. it will be the same as the Frame returned -c by astGetRegionFrame). -f by AST_GETREGIONFRAME). - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astGetRegionFrameSet() -f AST_GETREGIONFRAMESET = INTEGER -* A pointer to a deep copy of the FrameSet represented by the Region. -* Using this pointer to modify the FrameSet will have no effect on -* the Region. - -* Notes: -* - A null Object pointer (AST__NULL) will be returned if this -c function is invoked with the AST error status set, or if it -f function is invoked with STATUS set to an error value, or if it -* should fail for any reason. -*-- -*/ - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* Return a deep copy of the encapsulated FrameSet. */ - return astCopy( this->frameset ); -} - -void astInitRegionVtab_( AstRegionVtab *vtab, const char *name, int *status ) { -/* -*+ -* Name: -* astInitRegionVtab - -* Purpose: -* Initialise a virtual function table for a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astInitRegionVtab( AstRegionVtab *vtab, const char *name ) - -* Class Membership: -* Region vtab initialiser. - -* Description: -* This function initialises the component of a virtual function -* table which is used by the Region class. - -* Parameters: -* vtab -* Pointer to the virtual function table. The components used by -* all ancestral classes will be initialised if they have not already -* been initialised. -* name -* Pointer to a constant null-terminated character string which contains -* the name of the class to which the virtual function table belongs (it -* is this pointer value that will subsequently be returned by the Object -* astClass function). -*- -*/ - -/* Local Variables: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ - AstFrameVtab *frame; /* Pointer to Frame component of Vtab */ - AstMappingVtab *mapping; /* Pointer to Mapping component of Vtab */ - AstObjectVtab *object; /* Pointer to Object component of Vtab */ - -/* Check the local error status. */ - if ( !astOK ) return; - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(NULL); - -/* Initialize the component of the virtual function table used by the - parent class. */ - astInitFrameVtab( (AstFrameVtab *) vtab, name ); - -/* Store a unique "magic" value in the virtual function table. This - will be used (by astIsARegion) to determine if an object belongs - to this class. We can conveniently use the address of the (static) - class_check variable to generate this unique value. */ - vtab->id.check = &class_check; - vtab->id.parent = &(((AstFrameVtab *) vtab)->id); - -/* Initialise member function pointers. */ -/* ------------------------------------ */ - -/* Store pointers to the member functions (implemented here) that - provide virtual methods for this class. */ - vtab->ClearNegated = ClearNegated; - vtab->GetNegated = GetNegated; - vtab->SetNegated = SetNegated; - vtab->TestNegated = TestNegated; - - vtab->ClearRegionFS = ClearRegionFS; - vtab->GetRegionFS = GetRegionFS; - vtab->SetRegionFS = SetRegionFS; - vtab->TestRegionFS = TestRegionFS; - - vtab->ClearClosed = ClearClosed; - vtab->GetClosed = GetClosed; - vtab->SetClosed = SetClosed; - vtab->TestClosed = TestClosed; - - vtab->ClearMeshSize = ClearMeshSize; - vtab->GetMeshSize = GetMeshSize; - vtab->SetMeshSize = SetMeshSize; - vtab->TestMeshSize = TestMeshSize; - - vtab->ClearAdaptive = ClearAdaptive; - vtab->GetAdaptive = GetAdaptive; - vtab->SetAdaptive = SetAdaptive; - vtab->TestAdaptive = TestAdaptive; - - vtab->ClearFillFactor = ClearFillFactor; - vtab->GetFillFactor = GetFillFactor; - vtab->SetFillFactor = SetFillFactor; - vtab->TestFillFactor = TestFillFactor; - - vtab->ResetCache = ResetCache; - vtab->RegTrace = RegTrace; - vtab->GetBounded = GetBounded; - vtab->TestUnc = TestUnc; - vtab->ClearUnc = ClearUnc; - vtab->GetRegionFrame = GetRegionFrame; - vtab->GetRegionFrameSet = GetRegionFrameSet; - vtab->MapRegion = MapRegion; - vtab->Overlap = Overlap; - vtab->OverlapX = OverlapX; - vtab->Negate = Negate; - vtab->BndMesh = BndMesh; - vtab->BndBaseMesh = BndBaseMesh; - vtab->RegBaseGrid = RegBaseGrid; - vtab->RegBaseMesh = RegBaseMesh; - vtab->RegSplit = RegSplit; - vtab->RegBaseBox = RegBaseBox; - vtab->RegBaseBox2 = RegBaseBox2; - vtab->RegBasePick = RegBasePick; - vtab->RegCentre = RegCentre; - vtab->RegGrid = RegGrid; - vtab->RegMesh = RegMesh; - vtab->RegClearAttrib = RegClearAttrib; - vtab->RegSetAttrib = RegSetAttrib; - vtab->GetDefUnc = GetDefUnc; - vtab->GetNegation = GetNegation; - vtab->GetUncFrm = GetUncFrm; - vtab->SetUnc = SetUnc; - vtab->GetUnc = GetUnc; - vtab->ShowMesh = ShowMesh; - vtab->GetRegionBounds = GetRegionBounds; - vtab->GetRegionBounds2 = GetRegionBounds2; - vtab->GetRegionMesh = GetRegionMesh; - vtab->GetRegionPoints = GetRegionPoints; - vtab->RegOverlay = RegOverlay; - vtab->RegFrame = RegFrame; - vtab->RegDummyFS = RegDummyFS; - vtab->RegMapping = RegMapping; - vtab->RegPins = RegPins; - vtab->RegTransform = RegTransform; - vtab->BTransform = BTransform; - vtab->GetRegFS = GetRegFS; - vtab->SetRegFS = SetRegFS; - vtab->MaskB = MaskB; - vtab->MaskD = MaskD; - vtab->MaskF = MaskF; - vtab->MaskI = MaskI; - vtab->MaskL = MaskL; - vtab->MaskS = MaskS; - vtab->MaskUB = MaskUB; - vtab->MaskUI = MaskUI; - vtab->MaskUL = MaskUL; - vtab->MaskUS = MaskUS; -#if HAVE_LONG_DOUBLE /* Not normally implemented */ - vtab->MaskLD = MaskLD; -#endif - -/* Save the inherited pointers to methods that will be extended, and store - replacement pointers for methods which will be over-ridden by new member - functions implemented here. */ - object = (AstObjectVtab *) vtab; - mapping = (AstMappingVtab *) vtab; - frame = (AstFrameVtab *) vtab; - - parent_getobjsize = object->GetObjSize; - object->GetObjSize = GetObjSize; - - parent_getusedefs = object->GetUseDefs; - object->GetUseDefs = GetUseDefs; - -#if defined(THREAD_SAFE) - parent_managelock = object->ManageLock; - object->ManageLock = ManageLock; -#endif - - object->Cast = Cast; - object->Equal = Equal; - object->ClearAttrib = ClearAttrib; - object->GetAttrib = GetAttrib; - object->SetAttrib = SetAttrib; - object->TestAttrib = TestAttrib; - - mapping->ReportPoints = ReportPoints; - mapping->RemoveRegions = RemoveRegions; - mapping->Simplify = Simplify; - - frame->Abbrev = Abbrev; - frame->Angle = Angle; - frame->AxAngle = AxAngle; - frame->AxDistance = AxDistance; - frame->AxNorm = AxNorm; - frame->AxOffset = AxOffset; - frame->CheckPerm = CheckPerm; - frame->ClearDigits = ClearDigits; - frame->ClearDirection = ClearDirection; - frame->ClearDomain = ClearDomain; - frame->ClearFormat = ClearFormat; - frame->ClearLabel = ClearLabel; - frame->ClearMatchEnd = ClearMatchEnd; - frame->ClearMaxAxes = ClearMaxAxes; - frame->ClearMinAxes = ClearMinAxes; - frame->ClearPermute = ClearPermute; - frame->ClearPreserveAxes = ClearPreserveAxes; - frame->ClearSymbol = ClearSymbol; - frame->ClearTitle = ClearTitle; - frame->ClearUnit = ClearUnit; - frame->Convert = Convert; - frame->ConvertX = ConvertX; - frame->Distance = Distance; - frame->FindFrame = FindFrame; - frame->Format = Format; - frame->Centre = Centre; - frame->Gap = Gap; - frame->GetAxis = GetAxis; - frame->GetDigits = GetDigits; - frame->GetDirection = GetDirection; - frame->GetDomain = GetDomain; - frame->GetFormat = GetFormat; - frame->GetLabel = GetLabel; - frame->GetMatchEnd = GetMatchEnd; - frame->GetMaxAxes = GetMaxAxes; - frame->GetMinAxes = GetMinAxes; - frame->GetNaxes = GetNaxes; - frame->GetPerm = GetPerm; - frame->GetPermute = GetPermute; - frame->GetPreserveAxes = GetPreserveAxes; - frame->GetSymbol = GetSymbol; - frame->GetTitle = GetTitle; - frame->GetUnit = GetUnit; - frame->Intersect = Intersect; - frame->IsUnitFrame = IsUnitFrame; - frame->Match = Match; - frame->Norm = Norm; - frame->NormBox = NormBox; - frame->Offset = Offset; - frame->Offset2 = Offset2; - frame->Overlay = Overlay; - frame->PermAxes = PermAxes; - frame->PickAxes = PickAxes; - frame->Resolve = Resolve; - frame->ResolvePoints = ResolvePoints; - frame->SetAxis = SetAxis; - frame->SetDigits = SetDigits; - frame->SetDirection = SetDirection; - frame->SetDomain = SetDomain; - frame->SetFormat = SetFormat; - frame->SetLabel = SetLabel; - frame->SetMatchEnd = SetMatchEnd; - frame->SetMaxAxes = SetMaxAxes; - frame->SetMinAxes = SetMinAxes; - frame->SetPermute = SetPermute; - frame->SetPreserveAxes = SetPreserveAxes; - frame->SetSymbol = SetSymbol; - frame->SetTitle = SetTitle; - frame->SetUnit = SetUnit; - frame->SubFrame = SubFrame; - frame->SystemCode = SystemCode; - frame->SystemString = SystemString; - frame->TestDigits = TestDigits; - frame->TestDirection = TestDirection; - frame->TestDomain = TestDomain; - frame->TestFormat = TestFormat; - frame->TestLabel = TestLabel; - frame->TestMatchEnd = TestMatchEnd; - frame->TestMaxAxes = TestMaxAxes; - frame->TestMinAxes = TestMinAxes; - frame->TestPermute = TestPermute; - frame->TestPreserveAxes = TestPreserveAxes; - frame->TestSymbol = TestSymbol; - frame->TestTitle = TestTitle; - frame->TestUnit = TestUnit; - frame->Unformat = Unformat; - frame->ValidateAxis = ValidateAxis; - frame->ValidateAxisSelection = ValidateAxisSelection; - frame->ValidateSystem = ValidateSystem; - frame->LineDef = LineDef; - frame->LineContains = LineContains; - frame->LineCrossing = LineCrossing; - frame->LineOffset = LineOffset; - frame->MatchAxes = MatchAxes; - frame->MatchAxesX = MatchAxesX; - - frame->GetActiveUnit = GetActiveUnit; - frame->SetActiveUnit = SetActiveUnit; - frame->TestActiveUnit = TestActiveUnit; - - frame->GetTop = GetTop; - frame->SetTop = SetTop; - frame->TestTop = TestTop; - frame->ClearTop = ClearTop; - - frame->GetBottom = GetBottom; - frame->SetBottom = SetBottom; - frame->TestBottom = TestBottom; - frame->ClearBottom = ClearBottom; - - frame->GetEpoch = GetEpoch; - frame->SetEpoch = SetEpoch; - frame->TestEpoch = TestEpoch; - frame->ClearEpoch = ClearEpoch; - - frame->ClearObsAlt = ClearObsAlt; - frame->TestObsAlt = TestObsAlt; - frame->GetObsAlt = GetObsAlt; - frame->SetObsAlt = SetObsAlt; - - frame->ClearObsLat = ClearObsLat; - frame->TestObsLat = TestObsLat; - frame->GetObsLat = GetObsLat; - frame->SetObsLat = SetObsLat; - - frame->ClearObsLon = ClearObsLon; - frame->TestObsLon = TestObsLon; - frame->GetObsLon = GetObsLon; - frame->SetObsLon = SetObsLon; - - frame->GetSystem = GetSystem; - frame->SetSystem = SetSystem; - frame->TestSystem = TestSystem; - frame->ClearSystem = ClearSystem; - - frame->GetAlignSystem = GetAlignSystem; - frame->SetAlignSystem = SetAlignSystem; - frame->TestAlignSystem = TestAlignSystem; - frame->ClearAlignSystem = ClearAlignSystem; - -/* Declare the copy constructor, destructor and class dump - functions. */ - astSetDelete( vtab, Delete ); - astSetCopy( vtab, Copy ); - astSetDump( vtab, Dump, "Region", - "An area within a coordinate system" ); - -/* If we have just initialised the vtab for the current class, indicate - that the vtab is now initialised, and store a pointer to the class - identifier in the base "object" level of the vtab. */ - if( vtab == &class_vtab ) { - class_init = 1; - astSetVtabClassIdentifier( vtab, &(vtab->id) ); - } -} - -static void Intersect( AstFrame *this_frame, const double a1[2], - const double a2[2], const double b1[2], - const double b2[2], double cross[2], - int *status ) { -/* -* Name: -* Intersect - -* Purpose: -* Find the point of intersection between two geodesic curves. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void Intersect( AstFrame *this_frame, const double a1[2], -* const double a2[2], const double b1[2], -* const double b2[2], double cross[2], -* int *status ) - -* Class Membership: -* Region member function (over-rides the astIntersect method -* inherited from the Frame class). - -* Description: -* This function finds the coordinate values at the point of -* intersection between two geodesic curves. Each curve is specified -* by two points on the curve. - -* Parameters: -* this -* Pointer to the SkyFrame. -* a1 -* An array of double, with one element for each Frame axis. -* This should contain the coordinates of a point on the first -* geodesic curve. -* a2 -* An array of double, with one element for each Frame axis. -* This should contain the coordinates of a second point on the -* first geodesic curve. -* b1 -* An array of double, with one element for each Frame axis. -* This should contain the coordinates of a point on the second -* geodesic curve. -* b2 -* An array of double, with one element for each Frame axis. -* This should contain the coordinates of a second point on -* the second geodesic curve. -* cross -* An array of double, with one element for each Frame axis -* in which the coordinates of the required intersection -* point will be returned. These will be AST__BAD if the curves do -* not intersect. -* status -* Pointer to the inherited status variable. - -* Notes: -* - The geodesic curve used by this function is the path of -* shortest distance between two points, as defined by the -* astDistance function. -* - This function will return "bad" coordinate values (AST__BAD) -* if any of the input coordinates has this value. -* - For SkyFrames each curve will be a great circle, and in general -* each pair of curves will intersect at two diametrically opposite -* points on the sky. The returned position is the one which is -* closest to point "a1". -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astIntersect method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astIntersect( fr, a1, a2, b1, b2, cross ); - fr = astAnnul( fr ); -} - -static int IsUnitFrame( AstFrame *this, int *status ){ -/* -* Name: -* IsUnitFrame - -* Purpose: -* Is this Frame equivalent to a UnitMap? - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int IsUnitFrame( AstFrame *this, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astIsUnitFrame -* method inherited from the Frame class). - -* Description: -* This function returns a flag indicating if the supplied Frame is -* equivalent to a UnitMap when treated as a Mapping (note, the Frame -* class inherits from Mapping and therefore every Frame is also a Mapping). - -* Parameters: -* this -* Pointer to the Frame. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A non-zero value is returned if the supplied Frame is equivalent to -* a UnitMap when treated as a Mapping. - -*- -*/ - -/* Check the global error status. */ - if( !astOK ) return 0; - -/* The Region class is never equivalent to a UnitMap. */ - return 0; -} - -static int LineContains( AstFrame *this_frame, AstLineDef *l, int def, double *point, int *status ) { -/* -* Name: -* LineContains - -* Purpose: -* Determine if a line contains a point. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int LineContains( AstFrame *this, AstLineDef *l, int def, double *point, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astLineContains -* method inherited from the Frame class). - -* Description: -* This function determines if the supplied point is on the supplied -* line within the supplied Frame. The start point of the line is -* considered to be within the line, but the end point is not. The tests -* are that the point of closest approach of the line to the point should -* be between the start and end, and that the distance from the point to -* the point of closest aproach should be less than 1.0E-7 of the length -* of the line. - -* Parameters: -* this -* Pointer to the Frame. -* l -* Pointer to the structure defining the line. -* def -* Should be set non-zero if the "point" array was created by a -* call to astLineCrossing (in which case it may contain extra -* information following the axis values),and zero otherwise. -* point -* Point to an array containing the axis values of the point to be -* tested, possibly followed by extra cached information (see "def"). -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A non-zero value is returned if the line contains the point. - -* Notes: -* - The pointer supplied for "l" should have been created using the -* astLineDef method. These structures contained cached information about -* the lines which improve the efficiency of this method when many -* repeated calls are made. An error will be reported if the structure -* does not refer to the Frame specified by "this". -* - Zero will be returned if this function is invoked with the global -* error status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - int result; /* Returned value */ - -/* Initialise */ - result =0; - -/* Obtain a pointer to the Region's current Frame and then invoke the - method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - result = astLineContains( fr, l, def, point ); - fr = astAnnul( fr ); - -/* Return the result. */ - return result; -} - -static int LineCrossing( AstFrame *this_frame, AstLineDef *l1, AstLineDef *l2, - double **cross, int *status ) { -/* -* Name: -* LineCrossing - -* Purpose: -* Determine if two lines cross. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int LineCrossing( AstFrame *this, AstLineDef *l1, AstLineDef *l2, -* double **cross, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astLineCrossing -* method inherited from the Frame class). - -* Description: -* This function determines if the two suplied line segments cross, -* and if so returns the axis values at the point where they cross. -* A flag is also returned indicating if the crossing point occurs -* within the length of both line segments, or outside one or both of -* the line segments. - -* Parameters: -* this -* Pointer to the Frame. -* l1 -* Pointer to the structure defining the first line. -* l2 -* Pointer to the structure defining the second line. -* cross -* Pointer to a location at which to put a pointer to a dynamically -* alocated array containing the axis values at the crossing. If -* NULL is supplied no such array is returned. Otherwise, the returned -* array should be freed using astFree when no longer needed. If the -* lines are parallel (i.e. do not cross) then AST__BAD is returned for -* all axis values. Note usable axis values are returned even if the -* lines cross outside the segment defined by the start and end points -* of the lines. The order of axes in the returned array will take -* account of the current axis permutation array if appropriate. Note, -* sub-classes such as SkyFrame may append extra values to the end -* of the basic frame axis values. A NULL pointer is returned if an -* error occurs. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A non-zero value is returned if the lines cross at a point which is -* within the [start,end) segment of both lines. If the crossing point -* is outside this segment on either line, or if the lines are parallel, -* zero is returned. Note, the start point is considered to be inside -* the length of the segment, but the end point is outside. - -* Notes: -* - The pointers supplied for "l1" and "l2" should have been created -* using the astLineDef method. These structures contained cached -* information about the lines which improve the efficiency of this method -* when many repeated calls are made. An error will be reported if -* either structure does not refer to the Frame specified by "this". -* - Zero will be returned if this function is invoked with the global -* error status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - int result; /* Returned value */ - -/* Initialise */ - result =0; - -/* Obtain a pointer to the Region's current Frame and then invoke the - method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - result = astLineCrossing( fr, l1, l2, cross ); - fr = astAnnul( fr ); - -/* Return the result. */ - return result; -} - -static AstLineDef *LineDef( AstFrame *this_frame, const double start[2], - const double end[2], int *status ) { -/* -* Name: -* LineDef - -* Purpose: -* Creates a structure describing a line segment in a 2D Frame. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstLineDef *LineDef( AstFrame *this, const double start[2], -* const double end[2], int *status ) - -* Class Membership: -* Region member function (over-rides the protected astLineDef -* method inherited from the Frame class). - -* Description: -* This function creates a structure containing information describing a -* given line segment within the supplied 2D Frame. This may include -* information which allows other methods such as astLineCrossing to -* function more efficiently. Thus the returned structure acts as a -* cache to store intermediate values used by these other methods. - -* Parameters: -* this -* Pointer to the Frame. Must have 2 axes. -* start -* An array of 2 doubles marking the start of the line segment. -* end -* An array of 2 doubles marking the end of the line segment. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the memory structure containing the description of the -* line. This structure should be freed using astFree when no longer -* needed. A NULL pointer is returned (without error) if any of the -* supplied axis values are AST__BAD. - -* Notes: -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstLineDef *result; /* Returned value */ - -/* Initialise */ - result = NULL; - -/* Obtain a pointer to the Region's current Frame and then invoke the - method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - result = astLineDef( fr, start, end ); - fr = astAnnul( fr ); - -/* Return the result. */ - return result; -} - -static void LineOffset( AstFrame *this_frame, AstLineDef *line, double par, - double prp, double point[2], int *status ){ -/* -* Name: -* LineOffset - -* Purpose: -* Find a position close to a line. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void LineOffset( AstFrame *this, AstLineDef *line, double par, -* double prp, double point[2], int *status ) - -* Class Membership: -* Region member function (over-rides the protected astLineOffset -* method inherited from the Frame class). - -* Description: -* This function returns a position formed by moving a given distance along -* the supplied line, and then a given distance away from the supplied line. - -* Parameters: -* this -* Pointer to the Frame. -* line -* Pointer to the structure defining the line. -* par -* The distance to move along the line from the start towards the end. -* prp -* The distance to move at right angles to the line. Positive -* values result in movement to the left of the line, as seen from -* the observer, when moving from start towards the end. -* status -* Pointer to the inherited status variable. - -* Notes: -* - The pointer supplied for "line" should have been created using the -* astLineDef method. This structure contains cached information about the -* line which improves the efficiency of this method when many repeated -* calls are made. An error will be reported if the structure does not -* refer to the Frame specified by "this". -*/ - - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - -/* Obtain a pointer to the Region's current Frame and then invoke the - method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - astLineOffset( fr, line, par, prp, point ); - fr = astAnnul( fr ); -} - - -#if defined(THREAD_SAFE) -static int ManageLock( AstObject *this_object, int mode, int extra, - AstObject **fail, int *status ) { -/* -* Name: -* ManageLock - -* Purpose: -* Manage the thread lock on an Object. - -* Type: -* Private function. - -* Synopsis: -* #include "object.h" -* AstObject *ManageLock( AstObject *this, int mode, int extra, -* AstObject **fail, int *status ) - -* Class Membership: -* Region member function (over-rides the astManageLock protected -* method inherited from the parent class). - -* Description: -* This function manages the thread lock on the supplied Object. The -* lock can be locked, unlocked or checked by this function as -* deteremined by parameter "mode". See astLock for details of the way -* these locks are used. - -* Parameters: -* this -* Pointer to the Object. -* mode -* An integer flag indicating what the function should do: -* -* AST__LOCK: Lock the Object for exclusive use by the calling -* thread. The "extra" value indicates what should be done if the -* Object is already locked (wait or report an error - see astLock). -* -* AST__UNLOCK: Unlock the Object for use by other threads. -* -* AST__CHECKLOCK: Check that the object is locked for use by the -* calling thread (report an error if not). -* extra -* Extra mode-specific information. -* fail -* If a non-zero function value is returned, a pointer to the -* Object that caused the failure is returned at "*fail". This may -* be "this" or it may be an Object contained within "this". Note, -* the Object's reference count is not incremented, and so the -* returned pointer should not be annulled. A NULL pointer is -* returned if this function returns a value of zero. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A local status value: -* 0 - Success -* 1 - Could not lock or unlock the object because it was already -* locked by another thread. -* 2 - Failed to lock a POSIX mutex -* 3 - Failed to unlock a POSIX mutex -* 4 - Bad "mode" value supplied. - -* Notes: -* - This function attempts to execute even if an error has already -* occurred. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to Region structure */ - int result; /* Returned status value */ - -/* Initialise */ - result = 0; - -/* Check the supplied pointer is not NULL. */ - if( !this_object ) return result; - -/* Obtain a pointers to the Region structure. */ - this = (AstRegion *) this_object; - -/* Invoke the ManageLock method inherited from the parent class. */ - if( !result ) result = (*parent_managelock)( this_object, mode, extra, - fail, status ); - -/* Invoke the astManageLock method on any Objects contained within - the supplied Object. */ - if( !result ) result = astManageLock( this->frameset, mode, extra, fail ); - if( !result ) result = astManageLock( this->points, mode, extra, fail ); - if( !result ) result = astManageLock( this->unc, mode, extra, fail ); - if( !result ) result = astManageLock( this->negation, mode, extra, fail ); - if( !result ) result = astManageLock( this->defunc, mode, extra, fail ); - if( !result ) result = astManageLock( this->basemesh, mode, extra, fail ); - if( !result ) result = astManageLock( this->basegrid, mode, extra, fail ); - - return result; - -} -#endif - -static AstRegion *MapRegion( AstRegion *this, AstMapping *map0, - AstFrame *frame0, int *status ) { -/* -*+ -* Name: -* astMapRegion - -* Purpose: -* Transform a Region into a new Frame using a given Mapping. - -* Type: -* Protected virtual function. - -* Synopsis: -* #include "region.h" -* AstRegion *astMapRegion( AstRegion *this, AstMapping *map, -* AstFrame *frame ) - -* Class Membership: -* Region method. - -* Description: -* This function returns a pointer to a new Region which corresponds to -* supplied Region in some other specified coordinate system. A -* Mapping is supplied which transforms positions between the old and new -* coordinate systems. The new Region may not be of the same class as -* the original region. - -* Parameters: -* this -* Pointer to the Region. -* map -* Pointer to a Mapping which transforms positions from the -* coordinate system represented by the supplied Region to the -* coordinate system specified by "frame". The supplied Mapping should -* define both forward and inverse transformations, and these -* transformations should form a genuine inverse pair. That is, -* transforming a position using the forward transformation and then -* using the inverse transformation should produce the original input -* position. Some Mapping classes (such as PermMap, MathMap, SphMap) -* can result in Mappings for which this is not true. -* frame -* Pointer to a Frame describing the coordinate system in which -* the new Region is required. - -* Returned Value: -* astMapRegion() -* A pointer to a new Region. This Region will represent the area -* within the coordinate system specified by "frame" which corresponds -* to the supplied Region. - -* Notes: -* - This is the protected implementation of this function - it does -* not simplify the returned Region. The public implementation is -* astMapRegionID, which simplifies the returned Region. -* - A null Object pointer (AST__NULL) will be returned if this -* function is invoked with the AST error status set, or if it -* should fail for any reason. -*- -*/ - -/* Local Variables: */ - AstFrame *frame; - AstFrameSet *fs; - AstMapping *tmap; - AstMapping *usemap; - AstMapping *map; - AstPointSet *ps1; - AstPointSet *pst; - AstPointSet *ps2; - AstRegion *usethis; - AstRegion *result; - double **ptr1; - double **ptr2; - int *axflags; - int *inax; - int *keep; - int *outax; - int i; - int icurr; - int j; - int nax1; - int nkept; - int nnew; - int nold; - int np; - int ntotal; - int ok; - -/* Initialise returned value. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Initialise local variables */ - axflags = NULL; - -/* If a FrameSet was supplied for the Mapping, use the base->current - Mapping */ - if( astIsAFrameSet( map0 ) ) { - map = astGetMapping( (AstFrameSet *) map0, AST__BASE, AST__CURRENT ); - } else { - map = astClone( map0 ); - } - -/* If a FrameSet was supplied for the Frame, use the current Frame. */ - if( astIsAFrameSet( frame0 ) ) { - frame = astGetFrame( (AstFrameSet *) frame0, AST__CURRENT ); - } else { - frame = astClone( frame0 ); - } - -/* First check the Mapping is suitable. It must defined both a forward - and an inverse Mapping. */ - if( !astGetTranInverse( map ) ) { - astError( AST__NODEF, "astMapRegion(%s): The supplied %s does not " - "define an inverse transformation.", status, astGetClass( this ), - astGetClass( map ) ); - } else if( !astGetTranForward( map ) ) { - astError( AST__NODEF, "astMapRegion(%s): The supplied %s does not " - "define a forward transformation.", status, astGetClass( this ), - astGetClass( map ) ); - } - - -/* Get the number of axes in the supplied Region. */ - nold = astGetNaxes( this ); - -/* Get the number of axes in the returned Region. */ - nnew = astGetNaxes( frame ); - -/* The forward transformation must not introduce any bad axis values. We - can only perform this test reliably if the supplied Region has no bad - axis values. */ - ps1 = this->points; - if( ps1 ) { - nax1 = astGetNcoord( ps1 ); - np = astGetNpoint( ps1 ); - ptr1 = astGetPoints( ps1 ); - if( ptr1 ) { - -/* Check the axis values defining the Region are good. */ - ok = 1; - for( i = 0; i < nax1 && ok; i++ ){ - for( j = 0; j < np; j++ ) { - if( ptr1[ i ][ j ] == AST__BAD ){ - ok = 0; - break; - } - } - } - if( ok ) { - -/* Transform the points defining the supplied Region into the current Frame - of the Region. */ - pst = astRegTransform( this, ps1, 1, NULL, NULL ); - -/* The use the supplied Mapping to transfom them into the new Frame. */ - ps2 = astTransform( map, pst, 1, NULL ); - -/* Test if any of these axis values are bad. */ - ptr2 = astGetPoints( ps2 ); - if( ptr2 ) { - for( i = 0; i < nnew && ok; i++ ){ - for( j = 0; j < np; j++ ) { - if( ptr2[ i ][ j ] == AST__BAD ){ - ok = 0; - break; - } - } - } - if( !ok ) { - astError( AST__NODEF, "astMapRegion(%s): The region which " - "results from using the supplied %s to transform " - "the supplied %s is undefined.", status, astGetClass( this ), - astGetClass( map ), astGetClass( this ) ); - -/* If all axis values are good, use the inverse transformation of the - supplied Mapping to transform them back to the Frame of the supplied - Region. */ - } else { - pst = astAnnul( pst ); - pst = astTransform( map, ps2, 0, NULL ); - -/* Get a flag for each input of the supplied Mapping (i.e. each axis of - the supplied Region) which is non-zero if the inverse transformation - of the Mapping has produced any good axis values. */ - ptr1 = astGetPoints( pst ); - axflags = astCalloc( nold, sizeof(int) ); - if( astOK ) { - for( i = 0; i < nold; i++ ){ - for( j = 0; j < np; j++ ) { - if( ptr1[ i ][ j ] != AST__BAD ){ - axflags[ i ] = 1; - break; - } - } - } - } - } - } - ps2 = astAnnul( ps2 ); - pst = astAnnul( pst ); - } - } - } - -/* Assume we will be using the supplied Region (this) and Mapping (map). */ - usethis = astClone( this ); - usemap = astClone( map ); - -/* If the new Frame for the Region has fewer axes than the old Frame, see - if we can discard some base-frame axes. We only do this if the inverse - transformation would otherwise supply bad values for the unused axes. - Using bad axis values is not a good idea as some operations cannot be - performed if any bad values are supplied. Also having more axes than - needed is bad as it results in fewer mesh points per axis. */ - if( nnew < nold ) { - -/* First invert the Mapping since astMapSplit only allows selection of - inputs, and we want to select outputs. */ - astInvert( map ); - -/* Create an array holding the indices of the required inputs. */ - inax = astMalloc( nnew*sizeof(int) ); - if( astOK ) for( i = 0; i < nnew; i++ ) inax[i] = i; - -/* Attempt to split the mapping to extract a new mapping that omits any - unnecessary outputs (i.e. outputs that are indepenent of the selected - inputs). Check the Mapping was split successfully. */ - outax = astMapSplit( map, nnew, inax, &tmap ); - if( outax ) { - -/* Get the number of old axes that have been retained in the Mapping. */ - nkept = astGetNout( tmap ); - -/* Now we need to ensure that any unused axes for which the Mapping - creates non-bad values are retained (such values are significant - since they may determine whether the new Region is null or not). - We only need to do this if any of the outputs that were split off - above have been found to generate good values, as indicated by the - "axflags" array. Count the number of extra axes that need to be kept, - over and above those that are kept by the Mapping returned by - astMapSplit above. */ - ntotal = 0; - keep = NULL; - if( axflags ) { - keep = astMalloc( nold*sizeof(int) ); - if( astOK ) { - -/* Loop round each axis in the supplied Region. */ - for( i = 0; i < nold; i++ ) { - -/* Search the "outax" array to see if this axis was retained by astMapSplit. - If it was, append its index to the total list of axes to keep. */ - ok = 0; - for( j = 0; j < nkept; j++ ) { - if( outax[ j ] == i ) { - keep[ ntotal++ ] = i; - ok = 1; - break; - } - } - -/* If the axis was not retained by astMapSplit, but generates good axis - values, also append its index to the total list of axes to keep. */ - if( !ok && axflags[ i ] ) { - keep[ ntotal++ ] = i; - } - } - } - } - -/* If there are no extra axes to keep, then the Mapping returned by - astMapSplit above can be used as it is. */ - if( ntotal == nkept ) { - -/* The values in the "outax" array will hold the zero-based indices of - the original old axes that are retained by the new Mapping. We need to - create a copy of the supplied Region that includes only these axes. */ - usethis = astAnnul( usethis ); - usethis = astPickAxes( this, nkept, outax, NULL ); - -/* Use the temportary Mapping returned by astMapSplit in place of the - supplied Mapping (remember to invert to undo the inversion performed - above). */ - usemap = astAnnul( usemap ); - usemap = astClone( tmap ); - astInvert( usemap ); - -/* Free temporary resources. */ - tmap = astAnnul( tmap ); - outax = astFree( outax ); - -/* If we need to retain some extra axes because they generate good values - (even though they are independent of the new Frame axes)... */ - } else if( ntotal > nkept ){ - -/* We know the old Frame axes that we want to keep, so use astMapSplit - in the opposite direction - i.e. use it on the Mapping form old to - new. */ - astInvert( map ); - - tmap = astAnnul( tmap ); - outax = astFree( outax ); - - outax = astMapSplit( map, ntotal, keep, &tmap ); - if( outax ) { - - usethis = astAnnul( usethis ); - usethis = astPickAxes( this, ntotal, keep, NULL ); - - usemap = astAnnul( usemap ); - usemap = astClone( tmap ); - - tmap = astAnnul( tmap ); - outax = astFree( outax ); - - } - - astInvert( map ); - } - keep = astFree( keep ); - } - inax = astFree( inax ); - -/* Invert the Mapping again to bring it back to its original state. */ - astInvert( map ); - } - -/* Take a deep copy of the supplied Region. */ - result = astCopy( usethis ); - -/* Get a pointer to the encapsulated FrameSet. */ - if( astOK ) { - fs = result->frameset; - -/* Add in the new Frame and Mapping. First note the index of the original - current Frame. */ - icurr = astGetCurrent( fs ); - astAddFrame( fs, AST__CURRENT, usemap, frame ); - -/* Remove the original current Frame. */ - astRemoveFrame( fs, icurr ); - -/* The base and current Frames of the resulting FrameSet are now (in - general) different and so the Region should include its FrameSet in any - Dump. */ - astSetRegionFS( result, 1 ); - } - -/* Since the Mapping has been changed, any cached information calculated - on the basis of the Mapping properties may no longer be up to date. */ - astResetCache( result ); - -/* Free resources */ - usemap = astAnnul( usemap ); - usethis = astAnnul( usethis ); - map = astAnnul( map ); - frame = astAnnul( frame ); - axflags = astFree( axflags ); - -/* If not OK, annul the returned pointer. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -/* -*++ -* Name: -c astMask<X> -f AST_MASK<X> - -* Purpose: -* Mask a region of a data grid. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c int astMask<X>( AstRegion *this, AstMapping *map, int inside, int ndim, -c const int lbnd[], const int ubnd[], <Xtype> in[], -c <Xtype> val ) -f RESULT = AST_MASK<X>( THIS, MAP, INSIDE, NDIM, LBND, UBND, IN, VAL, -f STATUS ) - -* Class Membership: -* Mapping method. - -* Description: -* This is a set of functions for masking out regions within gridded data -* (e.g. an image). The functions modifies a given data grid by -* assigning a specified value to all samples which are inside (or outside -c if "inside" is zero) -f if INSIDE is .FALSE.) -* the specified Region. -* -* You should use a masking function which matches the numerical -* type of the data you are processing by replacing <X> in -c the generic function name astMask<X> by an appropriate 1- or -f the generic function name AST_MASK<X> by an appropriate 1- or -* 2-character type code. For example, if you are masking data -c with type "float", you should use the function astMaskF (see -f with type REAL, you should use the function AST_MASKR (see -* the "Data Type Codes" section below for the codes appropriate to -* other numerical types). - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to a Region. -c map -f MAP = INTEGER (Given) -* Pointer to a Mapping. The forward transformation should map -* positions in the coordinate system of the supplied Region -* into pixel coordinates as defined by the -c "lbnd" and "ubnd" parameters. A NULL pointer -f LBND and UBND arguments. A value of AST__NULL -* can be supplied if the coordinate system of the supplied Region -* corresponds to pixel coordinates. This is equivalent to -* supplying a UnitMap. -* -* The number of inputs for this Mapping (as given by its Nin attribute) -* should match the number of axes in the supplied Region (as given -* by the Naxes attribute of the Region). -* The number of outputs for the Mapping (as given by its Nout attribute) -* should match the number of -c grid dimensions given by the value of "ndim" -f grid dimensions given by the value of NDIM -* below. -c inside -f INSIDE = INTEGER (Given) -* A boolean value which indicates which pixel are to be masked. If -c a non-zero value -f .TRUE. -* is supplied, then all grid pixels with centres inside the supplied -* Region are assigned the value given by -c "val", -f VAL, -* and all other pixels are left unchanged. If -c zero -f .FALSE. -* is supplied, then all grid pixels with centres not inside the supplied -* Region are assigned the value given by -c "val", -f VAL, -* and all other pixels are left unchanged. Note, the Negated -* attribute of the Region is used to determine which pixel are -* inside the Region and which are outside. So the inside of a Region -* which has not been negated is the same as the outside of the -* corresponding negated Region. -* -* For types of Region such as PointList which have zero volume, -* pixel centres will rarely fall exactly within the Region. For -* this reason, the inclusion criterion is changed for zero-volume -* Regions so that pixels are included (or excluded) if any part of -* the Region passes through the pixel. For a PointList, this means -* that pixels are included (or excluded) if they contain at least -* one of the points listed in the PointList. -c ndim -f NDIM = INTEGER (Given) -* The number of dimensions in the input grid. This should be at -* least one. -c lbnd -f LBND( NDIM ) = INTEGER (Given) -c Pointer to an array of integers, with "ndim" elements, -f An array -* containing the coordinates of the centre of the first pixel -* in the input grid along each dimension. -c ubnd -f UBND( NDIM ) = INTEGER (Given) -c Pointer to an array of integers, with "ndim" elements, -f An array -* containing the coordinates of the centre of the last pixel in -* the input grid along each dimension. -* -c Note that "lbnd" and "ubnd" together define the shape -f Note that LBND and UBND together define the shape -* and size of the input grid, its extent along a particular -c (j'th) dimension being ubnd[j]-lbnd[j]+1 (assuming the -c index "j" to be zero-based). They also define -f (J'th) dimension being UBND(J)-LBND(J)+1. They also define -* the input grid's coordinate system, each pixel having unit -* extent along each dimension with integral coordinate values -* at its centre. -c in -f IN( * ) = <Xtype> (Given and Returned) -c Pointer to an array, with one element for each pixel in the -f An array, with one element for each pixel in the -* input grid, containing the data to be masked. The -* numerical type of this array should match the 1- or -* 2-character type code appended to the function name (e.g. if -c you are using astMaskF, the type of each array element -c should be "float"). -f you are using AST_MASKR, the type of each array element -f should be REAL). -* -* The storage order of data within this array should be such -* that the index of the first grid dimension varies most -* rapidly and that of the final dimension least rapidly -c (i.e. Fortran array indexing is used). -f (i.e. normal Fortran array storage order). -* -* On exit, the samples specified by -c "inside" are set to the value of "val". -f INSIDE are set to the value of VAL. -* All other samples are left unchanged. -c val -f VAL = <Xtype> (Given) -* This argument should have the same type as the elements of -c the "in" array. It specifies the value used to flag the -f the IN array. It specifies the value used to flag the -* masked data (see -c "inside"). -f INSIDE). -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astMask<X>() -f AST_MASK<X> = INTEGER -* The number of pixels to which a value of -c "badval" -f BADVAL -* has been assigned. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -* - An error will be reported if the overlap of the Region and -* the array cannot be determined. - -* Data Type Codes: -* To select the appropriate masking function, you should -c replace <X> in the generic function name astMask<X> with a -f replace <X> in the generic function name AST_MASK<X> with a -* 1- or 2-character data type code, so as to match the numerical -* type <Xtype> of the data you are processing, as follows: -c - D: double -c - F: float -c - L: long int -c - UL: unsigned long int -c - I: int -c - UI: unsigned int -c - S: short int -c - US: unsigned short int -c - B: byte (signed char) -c - UB: unsigned byte (unsigned char) -f - D: DOUBLE PRECISION -f - R: REAL -f - I: INTEGER -f - UI: INTEGER (treated as unsigned) -f - S: INTEGER*2 (short integer) -f - US: INTEGER*2 (short integer, treated as unsigned) -f - B: BYTE (treated as signed) -f - UB: BYTE (treated as unsigned) -* -c For example, astMaskD would be used to process "double" -c data, while astMaskS would be used to process "short int" -c data, etc. -f For example, AST_MASKD would be used to process DOUBLE -f PRECISION data, while AST_MASKS would be used to process -f short integer data (stored in an INTEGER*2 array), etc. -f -f For compatibility with other Starlink facilities, the codes W -f and UW are provided as synonyms for S and US respectively (but -f only in the Fortran interface to AST). - -*-- -*/ -/* Define a macro to implement the function for a specific data - type. */ -#define MAKE_MASK(X,Xtype) \ -static int Mask##X( AstRegion *this, AstMapping *map, int inside, int ndim, \ - const int lbnd[], const int ubnd[], \ - Xtype in[], Xtype val, int *status ) { \ -\ -/* Local Variables: */ \ - AstFrame *grid_frame; /* Pointer to Frame describing grid coords */ \ - AstRegion *used_region; /* Pointer to Region to be used by astResample */ \ - Xtype *c; /* Pointer to next array element */ \ - Xtype *d; /* Pointer to next array element */ \ - Xtype *out; /* Pointer to the array used for resample output */ \ - Xtype *tmp_out; /* Pointer to temporary output array */ \ - double *lbndgd; /* Pointer to array holding lower grid bounds */ \ - double *ubndgd; /* Pointer to array holding upper grid bounds */ \ - int *lbndg; /* Pointer to array holding lower grid bounds */ \ - int *ubndg; /* Pointer to array holding upper grid bounds */ \ - int idim; /* Loop counter for coordinate dimensions */ \ - int ipix; /* Loop counter for pixel index */ \ - int nax; /* Number of Region axes */ \ - int nin; /* Number of Mapping input coordinates */ \ - int nout; /* Number of Mapping output coordinates */ \ - int npix; /* Number of pixels in supplied array */ \ - int npixg; /* Number of pixels in bounding box */ \ - int result; /* Result value to return */ \ -\ -/* Initialise. */ \ - result = 0; \ -\ -/* Check the global error status. */ \ - if ( !astOK ) return result; \ -\ -/* Obtain value for the Naxes attribute of the Region. */ \ - nax = astGetNaxes( this ); \ -\ -/* If supplied, obtain values for the Nin and Nout attributes of the Mapping. */ \ - if( map ) { \ - nin = astGetNin( map ); \ - nout = astGetNout( map ); \ -\ -/* If OK, check that the number of mapping inputs matches the \ - number of axes in the Region. Report an error if necessary. */ \ - if ( astOK && ( nax != nin ) ) { \ - astError( AST__NGDIN, "astMask"#X"(%s): Bad number of mapping " \ - "inputs (%d).", status, astGetClass( this ), nin ); \ - astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \ - "to specify a position.", status, \ - astGetClass( this ), nax, ( nax == 1 ) ? "" : "s" ); \ - } \ -\ -/* If OK, check that the number of mapping outputs matches the \ - number of grid dimensions. Report an error if necessary. */ \ - if ( astOK && ( ndim != nout ) ) { \ - astError( AST__NGDIN, "astMask"#X"(%s): Bad number of mapping " \ - "outputs (%d).", status, astGetClass( this ), nout ); \ - astError( AST__NGDIN, "The pixel grid requires %d coordinate value%s " \ - "to specify a position.", status, \ - ndim, ( ndim == 1 ) ? "" : "s" ); \ - } \ -\ -/* Create a new Region by mapping the supplied Region with the supplied \ - Mapping. The resulting Region represents a region in grid coordinates. */ \ - grid_frame = astFrame( ndim, "Domain=grid", status ); \ - used_region = astMapRegion( this, map, grid_frame ); \ - grid_frame = astAnnul( grid_frame ); \ -\ -/* If no Mapping was supplied check that the number of grid dimensions \ - matches the number of axes in the Region.*/ \ - } else if ( astOK && ( ( ndim != nax ) || ( ndim < 1 ) ) ) { \ - used_region = NULL; \ - astError( AST__NGDIN, "astMask"#X"(%s): Bad number of input grid " \ - "dimensions (%d).", status, astGetClass( this ), ndim ); \ - if ( ndim != nax ) { \ - astError( AST__NGDIN, "The %s given requires %d coordinate value%s " \ - "to specify an input position.", status, \ - astGetClass( this ), nax, ( nax == 1 ) ? "" : "s" ); \ - } \ -\ -/* If no Mapping was supplied and the parameters look OK, clone the \ - supplied Region pointer for use later on. */ \ - } else { \ - used_region = astClone( this ); \ - } \ -\ -/* Check that the lower and upper bounds of the input grid are \ - consistent. Report an error if any pair is not. */ \ - if ( astOK ) { \ - for ( idim = 0; idim < ndim; idim++ ) { \ - if ( lbnd[ idim ] > ubnd[ idim ] ) { \ - astError( AST__GBDIN, "astMask"#X"(%s): Lower bound of " \ - "input grid (%d) exceeds corresponding upper bound " \ - "(%d).", status, astGetClass( this ), \ - lbnd[ idim ], ubnd[ idim ] ); \ - astError( AST__GBDIN, "Error in input dimension %d.", status, \ - idim + 1 ); \ - break; \ - } \ - } \ - } \ -\ -/* Allocate memory, and then get the bounding box of this new Region in its \ - current Frame (grid coordinates). This bounding box assumes the region \ - has not been negated. */ \ - lbndg = astMalloc( sizeof( int )*(size_t) ndim ); \ - ubndg = astMalloc( sizeof( int )*(size_t) ndim ); \ - lbndgd = astMalloc( sizeof( double )*(size_t) ndim ); \ - ubndgd = astMalloc( sizeof( double )*(size_t) ndim ); \ - if( astOK ) { \ - astGetRegionBounds( used_region, lbndgd, ubndgd ); \ -\ -/* We convert the floating point bounds to integer pixel bounds, and at \ - the same time expand the box by 2 pixels at each edge to ensure that \ - rounding errors etc do not cause any of the Region to fall outside (or \ - on) the box. Do not let the expanded box extend outside the supplied \ - array bounds. Also note the total number of pixels in the supplied \ - array, and in the bounding box. */ \ - npix = 1; \ - npixg = 1; \ - for ( idim = 0; idim < ndim; idim++ ) { \ - if( lbndgd[ idim ] != AST__BAD && ubndgd[ idim ] != AST__BAD ) { \ - lbndg[ idim ] = astMAX( lbnd[ idim ], (int)( lbndgd[ idim ] + 0.5 ) - 2 ); \ - ubndg[ idim ] = astMIN( ubnd[ idim ], (int)( ubndgd[ idim ] + 0.5 ) + 2 ); \ - } else { \ - lbndg[ idim ] = lbnd[ idim ]; \ - ubndg[ idim ] = ubnd[ idim ]; \ - } \ - npix *= ( ubnd[ idim ] - lbnd[ idim ] + 1 ); \ - if( npixg >= 0 ) npixg *= ( ubndg[ idim ] - lbndg[ idim ] + 1 ); \ - } \ -\ -/* If the bounding box is null, fill the mask with the supplied value if \ - we assigning the value to the outside of the region (do the opposite if \ - the Region has been negated). */ \ - if( npixg <= 0 && astOK ) { \ - if( ( inside != 0 ) == ( astGetNegated( used_region ) != 0 ) ) { \ - c = in; \ - for( ipix = 0; ipix < npix; ipix++ ) *(c++) = val; \ - result = npix; \ - } \ -\ -/* If the bounding box is null, return without action. */ \ - } else if( npixg > 0 && astOK ) { \ -\ -/* All points outside this box are either all inside, or all outside, the \ - Region. So we can speed up processing by setting all the points which are \ - outside the box to the supplied data value (if required). This is \ - faster than checking each point individually using the Transform method \ - of the Region. We do this by supplying an alternative output array to \ - the resampling function below, which has been pre-filled with "val" at \ - every pixel. */ \ - if( ( inside != 0 ) == ( astGetNegated( used_region ) != 0 ) ) { \ -\ -/* Allocate memory for the alternative output array, and fill it with \ - "val". */ \ - tmp_out = astMalloc( sizeof( Xtype )*(size_t) npix ); \ - if( tmp_out ) { \ - c = tmp_out; \ - for( ipix = 0; ipix < npix; ipix++ ) *(c++) = val; \ - result = npix - npixg; \ - } \ -\ -/* Indicate that we will use this temporary array rather than the \ - supplied array. */ \ - out = tmp_out; \ -\ -/* If the outside of the grid box is outside the region of interest it \ - will be unchanged in the resturned array. Therefore we can use the \ - supplied array as the output array below. */ \ - } else { \ - tmp_out = NULL; \ - out = in; \ - } \ -\ -/* Temporarily invert the Region if required. The Region Transform methods \ - leave interior points unchanged and assign AST__BAD to exterior points. \ - This is the opposite of what we want (which is to leave exterior \ - points unchanged and assign VAL to interior points), so we negate the \ - region if the inside is to be assigned the value VAL.*/ \ - if( inside ) astNegate( used_region ); \ -\ -/* Invoke astResample to mask just the region inside the bounding box found \ - above (specified by lbndg and ubndg), since all the points outside this \ - box will already contain their required value. */ \ - result += astResample##X( used_region, ndim, lbnd, ubnd, in, NULL, AST__NEAREST, \ - NULL, NULL, 0, 0.0, 100, val, ndim, \ - lbnd, ubnd, lbndg, ubndg, out, NULL ); \ -\ -/* Revert to the original setting of the Negated attribute. */ \ - if( inside ) astNegate( used_region ); \ -\ -/* If required, copy the output data from the temporary output array to \ - the supplied array, and then free the temporary output array. */ \ - if( tmp_out ) { \ - c = tmp_out; \ - d = in; \ - for( ipix = 0; ipix < npix; ipix++ ) *(d++) = *(c++); \ - tmp_out = astFree( tmp_out ); \ - }\ - }\ - } \ -\ -/* Free resources */ \ - ubndg = astFree( ubndg ); \ - lbndg = astFree( lbndg ); \ - ubndgd = astFree( ubndgd ); \ - lbndgd = astFree( lbndgd ); \ - used_region = astAnnul( used_region ); \ -\ -/* If an error occurred, clear the returned result. */ \ - if ( !astOK ) result = 0; \ -\ -/* Return the result. */ \ - return result; \ -} - -/* Expand the above macro to generate a function for each required - data type. */ -#if HAVE_LONG_DOUBLE /* Not normally implemented */ -MAKE_MASK(LD,long double) -#endif -MAKE_MASK(D,double) -MAKE_MASK(L,long int) -MAKE_MASK(UL,unsigned long int) -MAKE_MASK(I,int) -MAKE_MASK(UI,unsigned int) -MAKE_MASK(S,short int) -MAKE_MASK(US,unsigned short int) -MAKE_MASK(B,signed char) -MAKE_MASK(UB,unsigned char) -MAKE_MASK(F,float) - -/* Undefine the macro. */ -#undef MAKE_MASK - - - -static int Match( AstFrame *this_frame, AstFrame *target, int matchsub, - int **template_axes, int **target_axes, - AstMapping **map, AstFrame **result, int *status ) { -/* -* Name: -* Match - -* Purpose: -* Determine if conversion is possible between two coordinate systems. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int Match( AstFrame *template, AstFrame *target, int matchsub, -* int **template_axes, int **target_axes, -* AstMapping **map, AstFrame **result, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astMatch -* method inherited from the Frame class). - -* Description: -* This function matches the current Frame of a "template" Region -* to a "target" frame and determines whether it is possible to -* convert coordinates between them. If it is, a Mapping that -* performs the transformation is returned along with a new Frame -* that describes the coordinate system that results when this -* Mapping is applied to the current Frame of the target -* Region. In addition, information is returned to allow the axes -* in this "result" Frame to be associated with the corresponding -* axes in the target and template Frames from which they are -* derived. - -* Parameters: -* template -* Pointer to the template Region, whose current Frame -* describes the coordinate system (or set of possible -* coordinate systems) into which we wish to convert our -* coordinates. -* target -* Pointer to the target Frame. This describes the coordinate -* system in which we already have coordinates. -* matchsub -* If zero then a match only occurs if the template is of the same -* class as the target, or of a more specialised class. If non-zero -* then a match can occur even if this is not the case. -* template_axes -* Address of a location where a pointer to int will be returned -* if the requested coordinate conversion is possible. This -* pointer will point at a dynamically allocated array of -* integers with one element for each axis of the "result" Frame -* (see below). It must be freed by the caller (using astFree) -* when no longer required. -* -* For each axis in the result Frame, the corresponding element -* of this array will return the index of the axis in the -* template Region's current Frame from which it is -* derived. If it is not derived from any template Region -* axis, a value of -1 will be returned instead. -* target_axes -* Address of a location where a pointer to int will be returned -* if the requested coordinate conversion is possible. This -* pointer will point at a dynamically allocated array of -* integers with one element for each axis of the "result" Frame -* (see below). It must be freed by the caller (using astFree) -* when no longer required. -* -* For each axis in the result Frame, the corresponding element -* of this array will return the index of the target Frame axis -* from which it is derived. If it is not derived from any -* target Frame axis, a value of -1 will be returned instead. -* map -* Address of a location where a pointer to a new Mapping will -* be returned if the requested coordinate conversion is -* possible. If returned, the forward transformation of this -* Mapping may be used to convert coordinates between the target -* Frame and the result Frame (see below) and the inverse -* transformation will convert in the opposite direction. -* result -* Address of a location where a pointer to a new Frame will be -* returned if the requested coordinate conversion is -* possible. If returned, this Frame describes the coordinate -* system that results from applying the returned Mapping -* (above) to the "target" coordinate system. In general, this -* Frame will combine attributes from (and will therefore be -* more specific than) both the target Frame and the current -* Frame of the template Region. In particular, when the -* template allows the possibility of transformaing to any one -* of a set of alternative coordinate systems, the "result" -* Frame will indicate which of the alternatives was used. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A non-zero value is returned if the requested coordinate -* conversion is possible. Otherwise zero is returned (this will -* not in itself result in an error condition). - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to Region's current Frame */ - int match; /* Result to be returned */ - -/* Initialise the returned values. */ - *template_axes = NULL; - *target_axes = NULL; - *map = NULL; - *result = NULL; - match = 0; - -/* Check the global error status. */ - if ( !astOK ) return match; - -/* Invoke the parent astMatch method on the current Frame within the - encapsulated FrameSet within the Region. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - match = astMatch( fr, target, matchsub, template_axes, target_axes, map, result ); - fr = astAnnul( fr ); - -/* Return the result. */ - return match; -} - -static void MatchAxes( AstFrame *frm1_frame, AstFrame *frm2, int *axes, - int *status ) { -/* -* Name: -* MatchAxes - -* Purpose: -* Find any corresponding axes in two Frames. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void MatchAxes( AstFrame *frm1, AstFrame *frm2, int *axes ) -* int *status ) - -* Class Membership: -* Region member function (over-rides the protected astMatchAxes -* method inherited from the Frame class). - -* Description: -* This function looks for corresponding axes within two supplied -* Frames. An array of integers is returned that contains an element -* for each axis in the second supplied Frame. An element in this array -* will be set to zero if the associated axis within the second Frame -* has no corresponding axis within the first Frame. Otherwise, it -* will be set to the index (a non-zero positive integer) of the -* corresponding axis within the first supplied Frame. - -* Parameters: -* frm1 -* Pointer to the first Frame. -* frm2 -* Pointer to the second Frame. -* axes -* Pointer to an -* integer array in which to return the indices of the axes (within -* the second Frame) that correspond to each axis within the first -* Frame. Axis indices start at 1. A value of zero will be stored -* in the returned array for each axis in the first Frame that has -* no corresponding axis in the second Frame. -* -* The number of elements in this array must be greater than or -* equal to the number of axes in the first Frame. -* status -* Pointer to inherited status value. - -* Notes: -* - Corresponding axes are identified by the fact that a Mapping -* can be found between them using astFindFrame or astConvert. Thus, -* "corresponding axes" are not necessarily identical. For instance, -* SkyFrame axes in two Frames will match even if they describe -* different celestial coordinate systems -*/ - -/* Local Variables: */ - AstFrame *frm1; /* Pointer to Region's current Frame */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Invoke the astMatchAxesX method on frm2, passing it the current Frame - within the encapsulated FrameSet within the Region as "frm1". */ - frm1 = astGetFrame( ((AstRegion *) frm1_frame)->frameset, AST__CURRENT ); - astMatchAxesX( frm2, frm1, axes ); - frm1 = astAnnul( frm1 ); -} - -static void MatchAxesX( AstFrame *frm2_frame, AstFrame *frm1, int *axes, - int *status ) { -/* -* Name: -* MatchAxesX - -* Purpose: -* Find any corresponding axes in two Frames. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void MatchAxesX( AstFrame *frm2, AstFrame *frm1, int *axes ) -* int *status ) - -* Class Membership: -* Region member function (over-rides the protected astMatchAxesX -* method inherited from the Frame class). - -* This function looks for corresponding axes within two supplied -* Frames. An array of integers is returned that contains an element -* for each axis in the second supplied Frame. An element in this array -* will be set to zero if the associated axis within the second Frame -* has no corresponding axis within the first Frame. Otherwise, it -* will be set to the index (a non-zero positive integer) of the -* corresponding axis within the first supplied Frame. - -* Parameters: -* frm2 -* Pointer to the second Frame. -* frm1 -* Pointer to the first Frame. -* axes -* Pointer to an integer array in which to return the indices of -* the axes (within the first Frame) that correspond to each axis -* within the second Frame. Axis indices start at 1. A value of zero -* will be stored in the returned array for each axis in the second -* Frame that has no corresponding axis in the first Frame. -* -* The number of elements in this array must be greater than or -* equal to the number of axes in the second Frame. -* status -* Pointer to inherited status value. - -* Notes: -* - Corresponding axes are identified by the fact that a Mapping -* can be found between them using astFindFrame or astConvert. Thus, -* "corresponding axes" are not necessarily identical. For instance, -* SkyFrame axes in two Frames will match even if they describe -* different celestial coordinate systems -*/ - -/* Local Variables: */ - AstFrame *frm2; - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Get a pointer to the current Frame in the FrameSet. */ - frm2 = astGetFrame( ((AstRegion *) frm2_frame)->frameset, AST__CURRENT ); - -/* Invoke the astMatchAxesX on the current Frame. */ - astMatchAxesX( frm2, frm1, axes ); - -/* Free resources */ - frm2 = astAnnul( frm2 ); -} - -static void Negate( AstRegion *this, int *status ) { -/* -*++ -* Name: -c astNegate -f AST_NEGATE - -* Purpose: -* Negate the area represented by a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astNegate( AstRegion *this ) -f CALL AST_NEGATE( THIS, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function negates the area represented by a Region. That is, -* points which were previously inside the region will then be -* outside, and points which were outside will be inside. This is -* acomplished by toggling the state of the Negated attribute for -* the supplied region. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -f STATUS = INTEGER (Given and Returned) -f The global status. - -*-- -*/ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Toggle the Negated attribute. */ - astSetNegated( this, astGetNegated( this ) ? 0 : 1 ); - -} - -static void Norm( AstFrame *this_frame, double value[], int *status ) { -/* -* Name: -* Norm - -* Purpose: -* Normalise a set of Region coordinates. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void Norm( AstAxis *this, double value[], int *status ) - -* Class Membership: -* Region member function (over-rides the astNorm method -* inherited from the Frame class). - -* Description: -* This function converts a set of coordinate values for the -* current Frame of a Region, which might potentially be -* unsuitable for display to a user (for instance, may lie outside -* the expected range of values) into a set of acceptable -* alternative values suitable for display. -* -* Typically, for Frames whose axes represent cyclic values (such -* as angles or positions on the sky), this function wraps an -* arbitrary set of coordinates, so that they lie within the first -* cycle (say zero to 2*pi or -pi/2 to +pi/2). For Frames with -* ordinary linear axes, without constraints, this function will -* typically return the original coordinate values unchanged. - -* Parameters: -* this -* Pointer to the Region. -* value -* An array of double, with one element for each Region axis. -* This should contain the initial set of coordinate values, -* which will be modified in place. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to the current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astNorm method to obtain the new values. Annul the Frame - pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astNorm( fr, value ); - fr = astAnnul( fr ); -} - -static void NormBox( AstFrame *this_frame, double lbnd[], double ubnd[], - AstMapping *reg, int *status ) { -/* -* Name: -* NormBox - -* Purpose: -* Extend a box to include effect of any singularities in the Frame. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void astNormBox( AstFrame *this, double lbnd[], double ubnd[], -* AstMapping *reg, int *status ) - -* Class Membership: -* Region member function (over-rides the astNormBox method inherited -* from the Frame class). - -* Description: -* This function modifies a supplied box to include the effect of any -* singularities in the co-ordinate system represented by the Frame. -* For a normal Cartesian coordinate system, the box will be returned -* unchanged. Other classes of Frame may do other things. For instance, -* a SkyFrame will check to see if the box contains either the north -* or south pole and extend the box appropriately. - -* Parameters: -* this -* Pointer to the Frame. -* lbnd -* An array of double, with one element for each Frame axis -* (Naxes attribute). Initially, this should contain a set of -* lower axis bounds for the box. They will be modified on exit -* to include the effect of any singularities within the box. -* ubnd -* An array of double, with one element for each Frame axis -* (Naxes attribute). Initially, this should contain a set of -* upper axis bounds for the box. They will be modified on exit -* to include the effect of any singularities within the box. -* reg -* A Mapping which should be used to test if any singular points are -* inside or outside the box. The Mapping should leave an input -* position unchanged if the point is inside the box, and should -* set all bad if the point is outside the box. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to the current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astNormBox method to obtain the new values. Annul the Frame - pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astNormBox( fr, lbnd, ubnd, reg ); - fr = astAnnul( fr ); -} - -static void Offset( AstFrame *this_frame, const double point1[], - const double point2[], double offset, double point3[], int *status ) { -/* -* Name: -* Offset - -* Purpose: -* Calculate an offset along a geodesic curve. - -* Type: -* Public virtual function. - -* Synopsis: -* #include "region.h" -* void Offset( AstFrame *this, -* const double point1[], const double point2[], -* double offset, double point3[], int *status ) - -* Class Membership: -* Region member function (over-rides the protected astOffset -* method inherited from the Frame class). - -* Description: -* This function finds the Region coordinate values of a point -* which is offset a specified distance along the geodesic curve -* between two other points. - -* Parameters: -* this -* Pointer to the Region. -* point1 -* An array of double, with one element for each Region axis. -* This should contain the coordinates of the point marking the -* start of the geodesic curve. -* point2 -* An array of double, with one element for each Region axis -* This should contain the coordinates of the point marking the -* end of the geodesic curve. -* offset -* The required offset from the first point along the geodesic -* curve. If this is positive, it will be towards the second -* point. If it is negative, it will be in the opposite -* direction. This offset need not imply a position lying -* between the two points given, as the curve will be -* extrapolated if necessary. -* point3 -* An array of double, with one element for each Region axis -* in which the coordinates of the required point will be -* returned. -* status -* Pointer to the inherited status variable. - -* Notes: -* - The geodesic curve used by this function is the path of -* shortest distance between two points, as defined by the -* astDistance function. -* - This function will return "bad" coordinate values (AST__BAD) -* if any of the input coordinates has this value. -* - "Bad" coordinate values will also be returned if the two -* points supplied are coincident (or otherwise fail to uniquely -* specify a geodesic curve) but the requested offset is non-zero. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astOffset method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astOffset( fr, point1, point2, offset, point3 ); - fr = astAnnul( fr ); -} - -static double Offset2( AstFrame *this_frame, const double point1[2], - double angle, double offset, double point2[2], int *status ){ -/* -* Name: -* Offset2 - -* Purpose: -* Calculate an offset along a geodesic curve in a 2D Frame. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* double Offset2( AstFrame *this, const double point1[2], double angle, -* double offset, double point2[2], int *status ); - -* Class Membership: -* Region member function (over-rides the protected astOffset2 -* method inherited from the Frame class). - -* Description: -* This function finds the Frame coordinate values of a point which -* is offset a specified distance along the geodesic curve at a -* given angle from a specified starting point. It can only be -* used with 2-dimensional Frames. -* -* For example, in a basic Frame, this offset will be along the -* straight line joining two points. For a more specialised Frame -* describing a sky coordinate system, however, it would be along -* the great circle passing through two sky positions. - -* Parameters: -* this -* Pointer to the Frame. -* point1 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This should contain the coordinates of the -* point marking the start of the geodesic curve. -* angle -* The angle (in radians) from the positive direction of the second -* axis, to the direction of the required position, as seen from -* the starting position. Positive rotation is in the sense of -* rotation from the positive direction of axis 2 to the positive -* direction of axis 1. -* offset -* The required offset from the first point along the geodesic -* curve. If this is positive, it will be in the direction of the -* given angle. If it is negative, it will be in the opposite -* direction. -* point2 -* An array of double, with one element for each Frame axis -* in which the coordinates of the required point will be returned. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The direction of the geodesic curve at the end point. That is, the -* angle (in radians) between the positive direction of the second -* axis and the continuation of the geodesic curve at the requested -* end point. Positive rotation is in the sense of rotation from -* the positive direction of axis 2 to the positive direction of axis 1. - -* Notes: -* - The geodesic curve used by this function is the path of -* shortest distance between two points, as defined by the -* astDistance function. -* - An error will be reported if the Frame is not 2-dimensional. -* - This function will return "bad" coordinate values (AST__BAD) -* if any of the input coordinates has this value. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double result; /* Value to return */ - -/* Check the global error status. */ - if ( !astOK ) return AST__BAD; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astOffset2 method for this Frame. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astOffset2( fr, point1, angle, offset, point2 ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BAD; - -/* Return the result. */ - return result; -} - -static int Overlap( AstRegion *this, AstRegion *that, int *status ){ -/* -*++ -* Name: -c astOverlap -f AST_OVERLAP - -* Purpose: -* Test if two regions overlap each other. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c int astOverlap( AstRegion *this, AstRegion *that ) -f RESULT = AST_OVERLAP( THIS, THAT, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function returns an integer value indicating if the two -* supplied Regions overlap. The two Regions are converted to a commnon -* coordinate system before performing the check. If this conversion is -* not possible (for instance because the two Regions represent areas in -* different domains), then the check cannot be performed and a zero value -* is returned to indicate this. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the first Region. -c that -f THAT = INTEGER (Given) -* Pointer to the second Region. -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astOverlap() -f AST_OVERLAP = INTEGER -* A value indicating if there is any overlap between the two Regions. -* Possible values are: -* -* 0 - The check could not be performed because the second Region -* could not be mapped into the coordinate system of the first -* Region. -* -* 1 - There is no overlap between the two Regions. -* -* 2 - The first Region is completely inside the second Region. -* -* 3 - The second Region is completely inside the first Region. -* -* 4 - There is partial overlap between the two Regions. -* -* 5 - The Regions are identical to within their uncertainties. -* -* 6 - The second Region is the exact negation of the first Region -* to within their uncertainties. - -* Notes: -* - The returned values 5 and 6 do not check the value of the Closed -* attribute in the two Regions. -* - A value of zero will be returned if this function is invoked with the -* AST error status set, or if it should fail for any reason. -*-- - -* Implementation Notes: -* This function is simply a wrap-up for the protected astOverlapX -* method which performs the required processing but swaps the order -* of the two arguments. This is a trick to allow the astOverlap method -* to be over-ridden by derived classes on the basis of the class of either -* of the two arguments. -*/ - -/* Check the global error status. */ - if ( !astOK ) return 0; - -/* Invoke the "astOverlapX" method with the two arguments swapped. */ - return astOverlapX( that, this ); -} - -static int OverlapX( AstRegion *that, AstRegion *this, int *status ){ -/* -*+ -* Name: -* astOverlapX - -* Purpose: -* Test if two regions overlap each other. - -* Type: -* Protected virtual function. - -* Synopsis: -* #include "region.h" -* int astOverlapX( AstRegion *that, AstRegion *this ) - -* Class Membership: -* Region method. - -* Description: -* This function performs the processing for the public astOverlap -* method and has exactly the same interface except that the order -* of the two arguments is swapped. This is a trick to allow -* the astOverlap method to be over-ridden by derived classes on -* the basis of the class of either of its two arguments. -* -* See the astOverlap method for details of the interface. -*- -*/ - -/* Local Variables: */ - AstFrame *bfrm_reg1; /* Pointer to base Frame in "reg1" Frame */ - AstFrame *frm_reg1; /* Pointer to current Frame in "reg1" Frame */ - AstFrameSet *fs0; /* FrameSet connecting Region Frames */ - AstFrameSet *fs; /* FrameSet connecting Region Frames */ - AstMapping *cmap; /* Mapping connecting Region Frames */ - AstMapping *map; /* Mapping form "reg2" current to "reg1" base */ - AstMapping *map_reg1; /* Pointer to current->base Mapping in "reg1" */ - AstPointSet *ps1; /* Mesh covering second Region */ - AstPointSet *ps3; /* Mesh covering first Region */ - AstPointSet *ps4; /* Mesh covering first Region */ - AstPointSet *ps2; /* Mesh covering second Region */ - AstPointSet *reg2_mesh; /* Mesh covering second Region */ - AstPointSet *reg1_mesh; /* Mesh covering first Region */ - AstPointSet *reg2_submesh; /* Second Region mesh minus boundary points */ - AstRegion *reg1; /* Region to use as the first Region */ - AstRegion *reg2; /* Region to use as the second Region */ - AstRegion *unc1; /* "unc" mapped into Frame of first Region */ - AstRegion *unc; /* Uncertainty in second Region */ - double **ptr1; /* Pointer to mesh axis values */ - double **ptr; /* Pointer to pointset data */ - double *p; /* Pointer to next axis value */ - int *mask; /* Mask identifying common boundary points */ - int allbad; /* Were all axis values bad? */ - int allgood; /* Were all axis values good? */ - int bnd1; /* Does reg1 have a finite boundary */ - int bnd2; /* Does reg2 have a finite boundary */ - int bnd_that; /* Does "that" have a finite boundary */ - int bnd_this; /* Does "this" have a finite boundary */ - int case1; /* First region inside second region? */ - int first; /* First pass? */ - int good; /* Any good axis values found? */ - int i; /* Mesh axis index */ - int iax; /* Axis index */ - int inv0; /* Original FrameSet Invert flag */ - int ip; /* Index of point */ - int j; /* Mesh point index */ - int nc; /* Number of axis values per point */ - int np; /* Number of points in mesh */ - int result; /* Value to return */ - int reg1_neg; /* Was "reg1" negated to make it bounded? */ - int reg2_neg; /* Was "reg2" negated to make it bounded? */ - int that_neg; /* Was "that" negated to make it bounded? */ - int this_neg; /* Was "this" negated to make it bounded? */ - int touch; /* Do the Regions touch? */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Return 5 if the two Regions are equal using the astEqual method. */ - if( astEqual( this, that ) ) { - return 5; - -/* Return 6 if the two Regions are equal using the Equal method after - temporarily negating the first. */ - } else { - astNegate( this ); - result = astEqual( this, that ); - astNegate( this ); - if( result ) return 6; - } - -/* Get a FrameSet which connects the Frame represented by the second Region - to the Frame represented by the first Region. Check that the conection is - defined. */ - fs0 = astConvert( that, this, "" ); - if( !fs0 ) return 0; - inv0 = astGetInvert( fs0 ); - -/* The rest of this function tests for overlap by representing one of the - Regions as a mesh of points along its boundary, and then checking to see - if any of the points in this mesh fall inside or outside the other Region. - This can only be done if the Region has a boundary of finite length (e.g. - Circles, Boxes, etc). Other Regions (e.g. some Intervals) do not have - finite boundaries and consequently report an error if an attempt is made - to represent them using a boundary mesh. We now therefore check to see if - either of the two Regions has a finite boundary length. This will be the - case if the region is bounded, or if it can be made bounded simply by - negating it. If a Region is unbounded regardless of the setting of its - Negated flag, then it does not have a finite boundary. We leave the - Negated attributes (temporaily) set to the values that cause the - Regions to be bounded. Set flags to indicate if the Regions have been - negated. */ - bnd_this = astGetBounded( this ); - if( !bnd_this ) { - astNegate( this ); - bnd_this = astGetBounded( this ); - if( ! bnd_this ) { - astNegate( this ); - this_neg = 0; - } else { - this_neg = 1; - } - } else { - this_neg = 0; - } - - bnd_that = astGetBounded( that ); - if( !bnd_that ) { - astNegate( that ); - bnd_that = astGetBounded( that ); - if( ! bnd_that ) { - astNegate( that ); - that_neg = 0; - } else { - that_neg = 1; - } - } else { - that_neg = 0; - } - -/* If neither Regions has a finite boundary, then we cannot currently - determine any overlap, so report an error. Given more time, it - is probably possible to think of some way of determining overlap - between two unbounded Regions, but it will probably not be a common - requirement and so is currently put off to a rainy day. */ - if( !bnd_this && !bnd_that && astOK ) { - astError( AST__INTER, "astOverlap(Region): Neither of the two " - "supplied Regions (classes %s and %s) has a finite " - "boundary.", status, astGetClass(this), astGetClass(that) ); - astError( AST__INTER, "The current implementation of astOverlap " - "cannot determine the overlap between two Regions " - "unless at least one of them has a finite boundary." , status); - } - -/* If only one of the two Regions has a finite boundary, we must use its - mesh first. Choose the finite boundary Region as the "second" region. - Also store a flag indicating if the first Region has a finite boundary. */ - if( bnd_that ) { - reg1 = this; - reg2 = that; - bnd1 = bnd_this; - bnd2 = bnd_that; - reg1_neg = this_neg; - reg2_neg = that_neg; - } else { - reg1 = that; - reg2 = this; - bnd1 = bnd_that; - bnd2 = bnd_this; - reg1_neg = that_neg; - reg2_neg = this_neg; - } - -/* We may need to try again with the above selections swapped. We only do - this once though. Set a flag to indicate that we are about to start the - first pass. */ - first = 1; -L1: - -/* Get a FrameSet which connects the Frame represented by the second Region - to the Frame represented by the first Region. Check that the conection is - defined. */ - fs = astClone( fs0 ); - astSetInvert( fs, (reg2 == that ) ? inv0 : 1 - inv0 ); - if( fs ) { - -/* Get a pointer to the Frame represented by the first Region. */ - frm_reg1 = astGetFrame( reg1->frameset, AST__CURRENT ); - -/* Get a pointer to the Mapping from current to base Frame in the first - Region. */ - map_reg1 = astGetMapping( reg1->frameset, AST__CURRENT, AST__BASE ); - -/* Get the Mapping from the current Frame of the second Region to the - current Frame of the first Region. */ - cmap = astGetMapping( fs, AST__BASE, AST__CURRENT ); - -/* Combine these Mappings to get the Mapping from current Frame of the - second region to the base Frame of the first Region. */ - map = (AstMapping *) astCmpMap( cmap, map_reg1, 1, "", status ); - -/* Get a mesh of points covering the second Region. These points are - within the current Frame of the second Region. */ - reg2_mesh = astRegMesh( reg2 ); - -/* Transform this mesh into the base Frame of the first Region. */ - ps1 = astTransform( map, reg2_mesh, 1, NULL ); - -/* Check there are some good points in the transformed pointset. */ - good = 0; - np = astGetNpoint( ps1 ); - nc = astGetNcoord( ps1 ); - ptr1 = astGetPoints( ps1 ); - if( ptr1 ) { - for( i = 0; i < nc && !good; i++ ) { - for( j = 0; j < np; j++ ) { - if( ptr1[ i ][ j ] != AST__BAD ) { - good = 1; - break; - } - } - } - } - -/* If the transformed mesh contains no good points, swap the regions and - try again. */ - if( !good ) { - fs = astAnnul( fs ); - frm_reg1 = astAnnul( frm_reg1 ); - map_reg1 = astAnnul( map_reg1 ); - cmap = astAnnul( cmap ); - map = astAnnul( map ); - reg2_mesh = astAnnul( reg2_mesh ); - ps1 = astAnnul( ps1 ); - - if( first ) { - first = 0; - - if( !bnd_that ) { - reg1 = this; - reg2 = that; - bnd1 = bnd_this; - bnd2 = bnd_that; - reg1_neg = this_neg; - reg2_neg = that_neg; - } else { - reg1 = that; - reg2 = this; - bnd1 = bnd_that; - bnd2 = bnd_this; - reg1_neg = that_neg; - reg2_neg = this_neg; - } - goto L1; - - } else { - return 0; - } - } - -/* Also transform the Region describing the positional uncertainty within - the second supplied Region into the base Frame of the first supplied - Region. */ - unc = astGetUncFrm( reg2, AST__CURRENT ); - bfrm_reg1 = astGetFrame( reg1->frameset, AST__BASE ); - unc1 = astMapRegion( unc, map, bfrm_reg1 ); - -/* See if all points within this transformed mesh fall on the boundary of - the first Region, to within the joint uncertainty of the two Regions. If - so the two Regions have equivalent boundaries. We can only do this is - the first region is bounded. */ - if( astRegPins( reg1, ps1, unc1, &mask ) && good ) { - -/* If the boundaries are equivalent, the Regions are either identical or - are mutually exclusive. To distinguish between these cases, we - looked at the Bounded attributes. If the Bounded attribute is the same - for both Regions then they are identical, otherwise they are mutually - exclusive. */ - result = ( ( !reg1_neg && bnd1 ) == ( !reg2_neg && bnd2 ) ) ? 5 : 6; - -/* If the boundaries of the two Regions are not equivalent. */ - } else { - -/* Create a new PointSet containing those points from the mesh which are - not on the boundary of the first Region. These points are identified by - the mask array created by the astRegPins method above. */ - reg2_submesh = GetSubMesh( mask, reg2_mesh, status ); - -/* Transform the points in the submesh of the second Region into the - current Frame of the first Region. */ - (void ) astAnnul( ps1 ); - ps1 = astTransform( cmap, reg2_submesh, 1, NULL ); - -/* Transform this submesh using the first Region as a Mapping. Any points - outside the first region will be set bad in the output PointSet. */ - ps2 = astTransform( (AstMapping *) reg1, ps1, 1, NULL ); - -/* Get the number of axes and points in this PointSet. */ - nc = astGetNcoord( ps2 ); - np = astGetNpoint( ps2 ); - -/* Note if there were any common points (i.e. points on the boundary of - both regions). */ - touch = ( astGetNpoint( reg2_mesh ) != np ); - -/* Get pointers to the axis data in this PointSet, and check they can be - used safely. */ - ptr = astGetPoints( ps2 ); - if( astOK ) { - -/* Loop round all points checking if the axis values are bad. We want a - flag saying if there are any good axis values and another flag saying if - there are any bad axis values. */ - allbad = 1; - allgood = 1; - for( iax = 0; iax < nc; iax++ ) { - p = ptr[ iax ]; - for( ip = 0; ip < np; ip++,p++ ) { - if( *p == AST__BAD ) { - allgood = 0; - if( !allbad ) break; - } else { - allbad = 0; - if( !allgood ) break; - } - } - } - -/* If the entire mesh of the (potentially negated) second Region was either - on the boundary of, or inside, the (potentially negated) first region, - determine the result depending on whether the regions have been - negated and whether they are bounded. Check for impossible states (or - maybe just errors in my logic). */ - if( allgood ) { - -/* Second region has a mesh so it must be bounded. */ - if( !bnd2 && astOK ) { - astError( AST__INTER, "astOverlap(%s): Inconsistent " - "state 1 (internal AST programming error).", - status, astGetClass( this ) ); - -/* If the first region has been made bounded by negating it... */ - } else if( reg1_neg ) { - if( bnd1 ) { - -/* If the second region has been made bounded by negating it, then the - unnegated first region is completely inside the unnegated second region. */ - if( reg2_neg ) { - result = 2; - -/* If the second region was bounded without negating it, then there is - no overlap between the unnegated first region and the second region. */ - } else { - result = 1; - } - -/* If the first region has been negated then it should not be unbounded. - This is ensured by the nature of the code that sets the "this_neg" and - "that_neg" flags above. */ - } else if( astOK ) { - astError( AST__INTER, "astOverlap(%s): Inconsistent " - "state 2 (internal AST programming error).", - status, astGetClass( this ) ); - } - -/* If the first region was bounded without negating it, but the second - region was made bounded by negating it, there is partial overlap. */ - } else if( reg2_neg ) { - result = 4; - -/* If the first region was bounded without negating it, but the second - region was also bounded without negating it, the second region is - completely inside the first region. */ - } else { - result = 3; - } - -/* If part of the mesh of the second Region was inside the first region, - and part was outside, then there is partial ocverlap. */ - } else if( !allbad ) { - result = 4; - -/* If no part of the mesh of the (possibly negated) second Region was inside - the (possibly negated) first region ... */ - } else { - -/* First deal with cases where the first region is unbounded. */ - if( !bnd1 ) { - if( reg1_neg && astOK ) { - astError( AST__INTER, "astOverlap(%s): Inconsistent " - "state 5 (internal AST programming error).", - status, astGetClass( this ) ); - } else if( reg2_neg ){ - result = 2; - } else { - result = 1; - } - -/* The second region has a mesh so it must be bounded. */ - } else if( !bnd2 && astOK ) { - astError( AST__INTER, "astOverlap(%s): Inconsistent " - "state 6 (internal AST programming error).", - status, astGetClass( this ) ); - -/* So now we know both (possibly negated) regions are bounded. */ - } else { - -/* We know that none of the reg2 mesh points are inside the bounded reg1. - But this still leaves two cases: 1) reg1 could be contained completely - within reg2, or 2) there is no overlap between reg2 and reg1. To - distinguish between these two cases we use reg2 to transform a point - on the boundary of reg1. First get a mesh on the boundary of reg1. */ - reg1_mesh = astRegMesh( reg1 ); - -/* Transform this mesh into the coordinate system of the second Region. */ - ps3 = astTransform( cmap, reg1_mesh, 0, NULL ); - -/* Transform the points in this mesh using the second Region as a Mapping. - Any points outside the second region will be set bad in the output - PointSet. */ - ps4 = astTransform( (AstMapping *) reg2, ps3, 1, NULL ); - -/* Get pointers to the axis data in this PointSet,and check they can be - used safely. */ - ptr = astGetPoints( ps4 ); - if( astOK ) { - -/* Test the firts point and set a flag indicating if we are in case 1 (if - not, we must be in case 2). */ - case1 = ( ptr[ 0 ][ 0 ] != AST__BAD ); - -/* Apply logic similar to the other cases to determine the result. */ - if( reg1_neg ) { - if( case1 == ( reg2_neg != 0 ) ) { - result = 3; - } else { - result = 4; - } - } else { - if( case1 == ( reg2_neg != 0 ) ) { - result = 1; - } else { - result = 2; - } - } - } - -/* Free resources. */ - reg1_mesh = astAnnul( reg1_mesh ); - ps3 = astAnnul( ps3 ); - ps4 = astAnnul( ps4 ); - } - } - } - -/* If there was no intersection or overlap, but the regions touch, then we - consider there to be an intersection if either region is closed. */ - if( touch && result == 1 ) { - if( astGetClosed( this) || astGetClosed( that ) ) result = 4; - } - -/* Free resources.*/ - reg2_submesh = astAnnul( reg2_submesh ); - ps2 = astAnnul( ps2 ); - } - -/* Free resources.*/ - fs = astAnnul( fs ); - bfrm_reg1 = astAnnul( bfrm_reg1 ); - frm_reg1 = astAnnul( frm_reg1 ); - map_reg1 = astAnnul( map_reg1 ); - cmap = astAnnul( cmap ); - map = astAnnul( map ); - ps1 = astAnnul( ps1 ); - reg2_mesh = astAnnul( reg2_mesh ); - unc = astAnnul( unc ); - unc1 = astAnnul( unc1 ); - if( mask) mask = astFree( mask ); - } - fs0 = astAnnul( fs0 ); - -/* The returned value should take account of whether "this" or "that" is - the first Region. If "this" was used as the first Region, then the - result value calculated above is already correct. If "that" was used as - the first Region, then we need to change the result to swap "this" and - "that". */ - if( reg1 == that ) { - if( result == 2 ) { - result = 3; - } else if( result == 3 ) { - result = 2; - } - } - -/* Re-instate the original Negated flags. */ - if( this_neg ) astNegate( this ); - if( that_neg ) astNegate( that ); - -/* If not OK, return zero. */ - if( !astOK ) result = 0; - -/* Return the result. */ - return result; -} - -static void Overlay( AstFrame *template_frame, const int *template_axes, - AstFrame *result, int *status ) { -/* -* Name: -* Overlay - -* Purpose: -* Overlay the attributes of a template Region on to another Frame. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void Overlay( AstFrame *template, const int *template_axes, -* AstFrame *result, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astOverlay -* method inherited from the Frame class). - -* Description: -* This function overlays attributes from the current Frame of a -* Region on to another Frame, so as to over-ride selected -* attributes of that second Frame. Normally only those attributes -* which have been specifically set in the template will be -* transferred. This implements a form of defaulting, in which a -* Frame acquires attributes from the template, but retains its -* original attributes (as the default) if new values have not -* previously been explicitly set in the template. - -* Parameters: -* template -* Pointer to the template Region, for whose current Frame -* values should have been explicitly set for any attribute -* which is to be transferred. -* template_axes -* Pointer to an array of int, with one element for each axis of -* the "result" Frame (see below). For each axis in the result -* frame, the corresponding element of this array should contain -* the (zero-based) index of the axis in the current Frame of -* the template Region to which it corresponds. This array is -* used to establish from which template Frame axis any -* axis-dependent attributes should be obtained. -* -* If any axis in the result Frame is not associated with a -* template Frame axis, the corresponding element of this array -* should be set to -1. -* -* If a NULL pointer is supplied, the template and result axis -* indices are assumed to be identical. -* result -* Pointer to the Frame which is to receive the new attribute values. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the current Frame in the Region and invoke its - astOverlay method to overlay its attributes. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( ((AstRegion *) template_frame)->frameset, AST__CURRENT ); - astOverlay( fr, template_axes, result ); - fr = astAnnul( fr ); -} - -static void PermAxes( AstFrame *this_frame, const int perm[], int *status ) { -/* -* Name: -* PermAxes - -* Purpose: -* Permute the order of a Region's axes. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void PermAxes( AstFrame *this, const int perm[], int *status ) - -* Class Membership: -* Region member function (over-rides the astPermAxes method -* inherited from the Frame class). - -* Description: -* This function permutes the order in which the axes in the -* current Frame of a Region occur. - -* Parameters: -* this -* Pointer to the Region. -* perm -* An array of int (with one element for each axis of the -* Region's current Frame) which lists the axes in their new -* order. Each element of this array should be a (zero-based) -* axis index identifying the axes according to their old -* (un-permuted) order. -* status -* Pointer to the inherited status variable. - -* Notes: -* - Only genuine permutations of the axis order are permitted, so -* each axis must be referenced exactly once in the "perm" array. -* - If more than one axis permutation is applied to the same Frame -* in a Region, the effects are cumulative. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Invoke the astPermAxes method on the encapsulated FrameSet. */ - astPermAxes( this->frameset, perm ); - -} - -static AstFrame *PickAxes( AstFrame *this_frame, int naxes, const int axes[], - AstMapping **map, int *status ) { -/* -* Name: -* PickAxes - -* Purpose: -* Create a new Frame by picking axes from a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstFrame *PickAxes( AstFrame *this, int naxes, const int axes[], -* AstMapping **map, int *status ) - -* Class Membership: -* Region member function (over-rides the astPickAxes protected -* method inherited from the Frame class). - -* Description: -* This function creates a new Frame whose axes are copies of axes -* picked from the encapsulated Frame of an existing Region. Other -* Frame attributes are also copied from this existing Frame to the -* new Frame. Zero or more of the original axes may be picked in -* any order, but each can be used only once. Additional axes (with -* default characteristics) may be included in the new Frame if -* required. -* -* Optionally, a Mapping that converts between the original Frame's -* axes and those of the new Frame may also be returned. - -* Parameters: -* this -* Pointer to the Region. -* naxes -* The number of axes required in the new Frame. -* axes -* Pointer to an array of int with naxes elements. This should -* contain (zero based) axis indices specifying the axes which -* are to be included in the new Frame, in the order -* required. Each axis index may occur only once. -* -* If additional (default) axes are also to be included, the -* corresponding elements of this array should be set to -1. -* map -* Address of a location to receive a pointer to a new -* Mapping. This will be a PermMap (or a UnitMap as a special -* case) that describes the axis permutation that has taken -* place between the current Frame of the Region and the new -* Frame. The forward transformation will convert from the -* original Region's axes to the new one's, and vice versa. -* -* If this Mapping is not required, a NULL value may be supplied -* for this parameter. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to the new Frame. - -* Notes: -* - The class of object returned may differ from that of the -* original current Frame, depending on which axes are -* selected. For example, if a single axis is picked from a -* SkyFrame (which always has two axes), the resulting Frame cannot -* be a valid SkyFrame, so will revert to the parent class (Frame) -* instead. -* - The new Frame contains a deep copy of all the data selected -* from the original current Frame. Modifying the new Frame will -* therefore not affect the Region or the Frames it contains. -* - A NULL pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *cfrm; /* Current Frame from input Region */ - AstFrame *frame; /* Pointer to Frame to be returned */ - AstMapping *cbmap; /* Base->current Mapping from input Region */ - AstMapping *fsmap; /* Mapping from selected current to base axes */ - AstRegion *breg; /* Region spanning selected base Frame axes */ - AstRegion *creg; /* Region spanning selected current Frame axes */ - AstRegion *this; /* Pointer to Region structure */ - int *base_axes; /* Holds selected base frame axis indices */ - int def; /* Were any default axes requested? */ - int i; /* Axis index */ - int nbase; /* No. of selected base Frame axes */ - -/* Initialise the returned pointers. */ - if ( map ) *map = NULL; - frame = NULL; - -/* Check the global error status. */ - if ( !astOK ) return frame; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Check that a valid set of axes is being selected . */ - astValidateAxisSelection( this, naxes, axes, "astPickAxes" ); - -/* Pick the required axes from the current Frame of the encapsulated - FrameSet. */ - cfrm = astGetFrame( this->frameset, AST__CURRENT ); - frame = astPickAxes( cfrm, naxes, axes, map ); - -/* See if any default axes are to be included in the returned Frame. */ - def = 0; - for( i = 0; i < naxes; i++ ) { - if( axes[ i ] < 0 ) def = 1; - } - -/* Regions cannot yet include extra default axes in the returned Frame - so return a basic Frame if any default axes were requested. */ - if( ! def ) { - -/* We now see if the requested set of current Frame axes correspond to a - unique set of base Frame axes. If they do, we may be able to return a - Region spanning the selected axes rather than just a Frame. The check - is performed by attempting to split the current->base Mapping. */ - cbmap = astGetMapping( this->frameset, AST__CURRENT, AST__BASE ); - base_axes = astMapSplit( cbmap, naxes, axes, &fsmap ); - -/* Check the Mapping could be split. */ - if( base_axes ) { - -/* Store the number of base Frame axes that correspond to the requested - set of current Frame axes. */ - nbase = astGetNout( fsmap ); - -/* Attempt to create a new Region that spans the corresponding set of - base Frame axes. */ - breg = astRegBasePick( this, nbase, base_axes ); - if( breg ) { - -/* Use the split Mapping to map the base Frame region into the requested - Frame. We invert the "fsmap" first so that it maps the selected base - Frame axes into the selected current Frame axes. */ - astInvert( fsmap ); - creg = astMapRegion( breg, fsmap, frame ); - -/* Copy properties from the old Region to the new Region. */ - astRegOverlay( creg, this, 0 ); - -/* Return this new Region in place of the simple Frame found above. */ - (void) astAnnul( frame ); - frame = (AstFrame *) creg; - -/* Free resources */ - breg = astAnnul( breg ); - } - fsmap = astAnnul( fsmap ); - base_axes = astFree( base_axes ); - } - cbmap = astAnnul( cbmap ); - } - cfrm = astAnnul( cfrm ); - -/* If an error occurred, annul the Mapping pointer (if requested) and - the new Frame pointer. */ - if ( !astOK ) { - if ( map ) *map = astAnnul( *map ); - frame = astAnnul( frame ); - } - -/* Return the pointer to the new Frame. */ - return frame; -} - -static void RegBaseBox( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*+ -* Name: -* astRegBaseBox - -* Purpose: -* Returns the bounding box of an un-negated Region in the base Frame of -* the encapsulated FrameSet. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astRegBaseBox( AstRegion *this, double *lbnd, double *ubnd ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns the upper and lower axis bounds of a Region in -* the base Frame of the encapsulated FrameSet, assuming the Region -* has not been negated. That is, the value of the Negated attribute -* is ignored. - -* Parameters: -* this -* Pointer to the Region. -* lbnd -* Pointer to an array in which to return the lower axis bounds -* covered by the Region in the base Frame of the encapsulated -* FrameSet. It should have at least as many elements as there are -* axes in the base Frame. -* ubnd -* Pointer to an array in which to return the upper axis bounds -* covered by the Region in the base Frame of the encapsulated -* FrameSet. It should have at least as many elements as there are -* axes in the base Frame. - -*- -*/ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* This abstract implementation simply reports an error. All sub-classes of - Region should over-ride this to return appropriate values. */ - astError( AST__INTER, "astRegBaseBox(%s): The %s class does not implement " - "the astRegBaseBox method inherited from the Region class " - "(internal AST programming error).", status, astGetClass( this ), - astGetClass( this ) ); -} - -static void RegBaseBox2( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*+ -* Name: -* astRegBaseBox2 - -* Purpose: -* Returns the bounding box of an un-negated Region in the base Frame of -* the encapsulated FrameSet. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astRegBaseBox2( AstRegion *this, double *lbnd, double *ubnd ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function is similar to astRegBaseBox in that it returns the -* upper and lower axis bounds of a Region in the base Frame of the -* encapsulated FrameSet. But, in addition to assuming that the -* supplied Region has not been negated, it also assumes that any -* component Regions contained within the supplied Region have not been -* negated. - -* Parameters: -* this -* Pointer to the Region. -* lbnd -* Pointer to an array in which to return the lower axis bounds -* covered by the Region in the base Frame of the encapsulated -* FrameSet. It should have at least as many elements as there are -* axes in the base Frame. -* ubnd -* Pointer to an array in which to return the upper axis bounds -* covered by the Region in the base Frame of the encapsulated -* FrameSet. It should have at least as many elements as there are -* axes in the base Frame. - -*- -*/ - -/* This base class implementation simply calls astRegBaseBox. Sub-classes - which contain component Regions should override it. */ - astRegBaseBox( this, lbnd, ubnd ); - -} - -static AstPointSet *RegBaseGrid( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astRegBaseGrid - -* Purpose: -* Return a PointSet containing points spread through the volume of a -* Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astRegBaseGrid( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a set of points spread -* through the volume of the Region. The points refer to the base Frame of -* the encapsulated FrameSet. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Pointer to the PointSet. If the Region is unbounded, a NULL pointer -* will be returned. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables: */ - AstBox *box; - AstFrame *frmb; - AstPointSet *ps1; - AstPointSet *ps2; - AstPointSet *result; - double **ptr2; - double **ptr; - double *lbnd; - double *ubnd; - int good; - int ic; - int ip; - int ipr; - int meshsize; - int naxb; - int np; - int npnt2; - int ntry; - -/* Initialise */ - result= NULL; - -/* Check the local error status. */ - if ( !astOK ) return NULL; - -/* If the Region structure contains a pointer to a PointSet holding - positions spread over the volume of the Region in the base Frame, - return it. */ - if( this->basegrid ) { - result = astClone( this->basegrid ); - -/* Otherwise, check the Region is bounded. */ - } else if( astGetBounded( this ) ) { - -/* Get the original MeshSize attribute. */ - meshsize = astGetMeshSize( this ); - -/* Get the base Frame bounding box. */ - naxb = astGetNin( this->frameset ); - lbnd = astMalloc( sizeof( double )*(size_t)naxb ); - ubnd = astMalloc( sizeof( double )*(size_t)naxb ); - astRegBaseBox( this, lbnd, ubnd ); - -/* Create a Box covering this bounding box. */ - frmb = astGetFrame( this->frameset, AST__BASE ); - box = astBox( frmb, 1, lbnd, ubnd, NULL, "", status ); - -/* Loop until we have a grid of nearly the right size. Make at most three - attempts. */ - ipr = 0; - np = meshsize; - ntry = 0; - while( ntry++ < 3 ) { - -/* Copy the MeshSize attribute to the new Box since this will be used by - the invocation of astRegBaseGrid below. */ - astSetMeshSize( box, np ); - -/* Invoke the Box astRegGrid method. Note, the Box class overrides this - implementation of astRegBaseGrid and does not (must not) invoke this - implementation, in order to avoid an infinite loop. */ - ps1 = astRegBaseGrid( box ); - -/* Some of the base Frame points in the above bounding box will fall outside - the supplied Region. Use the Region as a Mapping to determine which they - are. Since the points are base Frame points, use astBTransform rather - than astTransform. */ - ps2 = astBTransform( this, ps1, 1, NULL ); - -/* We now create a PointSet which is a copy of "ps2" but with all the bad - points (i.e. the points in the bounding box grid which are not inside - the supplied Region) removed. Create a result PointSet which is the same - size as "ps2", then copy just the good points from "ps2" to the result - PointSet, keeping a record of the number of points copied. */ - ptr2 = astGetPoints( ps2 ); - npnt2 = astGetNpoint( ps2 ); - result = astPointSet( npnt2, naxb, "", status ); - ptr = astGetPoints( result ); - if( astOK ) { - -/* Initialise the index of the next point to be stored in "result". */ - ipr = 0; - -/* Loop round all points in "ps2" */ - for( ip = 0; ip < npnt2; ip++ ) { - -/* Copy each axis value for this point from "ps2" to "result". If a bad - axis value is encountered, flag that the point is bad and break out of - the axis loop. */ - good = 1; - for( ic = 0; ic < naxb; ic++ ) { - if( ptr2[ ic ][ ip ] == AST__BAD ) { - good = 0; - break; - } else { - ptr[ ic ][ ipr ] = ptr2[ ic ][ ip ]; - } - } - -/* If the current point has no bad axis values, increment the index of - the next point to be stored in "result". */ - if( good ) ipr++; - } - } - -/* Free resources */ - ps1 = astAnnul( ps1 ); - ps2 = astAnnul( ps2 ); - -/* Leave the loop if an error has occurred. */ - if( !astOK ) break; - -/* If the number of points in the grid is within 5% of the target value, - it is good enough, so break. */ - if( fabs( (double)( ipr - meshsize ) )/meshsize < 0.05 ) break; - -/* Otherwise, adjust the target size of the grid by the ratio by which it - is in error. Don't do this if we have reached the maximum number of - re-tries. */ - if( ntry < 3 ) { - if( ipr == 0 ) { - np *= 10; - } else { - np *= (double)meshsize/(double)ipr; - } - result = astAnnul( result ); - } - } - -/* Truncate the "result" PointSet to exclude any unused space at the end - of the axis values arrays. */ - if( astOK ) astSetNpoint( result, ipr ); - -/* Free resources */ - lbnd = astFree( lbnd ); - ubnd = astFree( ubnd ); - frmb = astAnnul( frmb ); - box = astAnnul( box ); - -/* Cache the new grid for future use. */ - if( astOK ) this->basegrid = astClone( result ); - } - -/* Annul the result if an error occurred. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result */ - return result; -} - -static AstRegion **RegSplit( AstRegion *this, int *nlist, int *status ){ -/* -*+ -* Name: -* astRegSplit - -* Purpose: -* Split a Region into a list of disjoint component Regions. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion **astRegSplit( AstRegion *this, int *nlist ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function splits the supplied Region into a set of disjoint -* component Regions. If the Region cannot be split, then the returned -* array contains only one pointer - a clone of the supplied Region -* pointer. - -* Parameters: -* this -* Pointer to the Region. -* nlist -* Pointer to an int in which to return the number of elements in -* the returned array. - -* Returned Value: -* Pointer to dynamically alloctaed memory holding an array of Region -* pointers. The length of this array is given by the value returned -* in "*nlist". The pointers in the returned array should be annulled -* using astAnnul when no longer needed, and the memory used to hold -* the array should be freed using astFree. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables; */ - AstRegion **result; - -/* Initialise. */ - result = NULL; - *nlist = 0; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* The base class just returns an array containing a clone of the - supplied Region pointer. */ - result = astMalloc( sizeof( *result ) ); - if( astOK ) { - result[ 0 ] = astClone( this ); - *nlist = 1; - } - - if( !astOK ) { - result = astFree( result ); - *nlist = 0; - } - - return result; -} - -static AstPointSet *RegBaseMesh( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astRegBaseMesh - -* Purpose: -* Return a PointSet containing points spread around the boundary of a -* Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astRegBaseMesh( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a set of points on the -* boundary of the Region. The points refer to the base Frame of -* the encapsulated FrameSet. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Pointer to the PointSet. The axis values in this PointSet will have -* associated accuracies derived from the uncertainties which were -* supplied when the Region was created. -* -* If the Region has no boundary (i.e. is equivalent to a NullRegion), the -* returned PointSet will contain a single point with a value of AST__BAD -* on every axis. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Check the local error status. */ - if ( !astOK ) return NULL; - -/* This abstract method must be over-ridden by each concrete sub-class. - Report an error if this null imlementation is called.*/ - astError( AST__INTER, "astRegBaseMesh(%s): The %s class does not implement " - "the astRegBaseMesh method inherited from the Region class " - "(internal AST programming error).", status, astGetClass( this ), - astGetClass( this ) ); - return NULL; -} - -static AstRegion *RegBasePick( AstRegion *this, int naxes, const int *axes, - int *status ){ -/* -*+ -* Name: -* astRegBasePick - -* Purpose: -* Return a Region formed by picking selected base Frame axes from the -* supplied Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *astRegBasePick( AstRegion *this, int naxes, const int *axes ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function attempts to return a Region that is spanned by selected -* axes from the base Frame of the encapsulated FrameSet of the supplied -* Region. This may or may not be possible, depending on the class of -* Region. If it is not possible a NULL pointer is returned. - -* Parameters: -* this -* Pointer to the Region. -* naxes -* The number of base Frame axes to select. -* axes -* An array holding the zero-based indices of the base Frame axes -* that are to be selected. - -* Returned Value: -* Pointer to the Region, or NULL if no region can be formed. - -* Notes: -* - This base implementation returns NULL unless all base Frame axes -* are selected (possibly in a permuted order). -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ -/* Local Variables: */ - AstFrame *fr; /* Pointer to the Region's base Frame */ - AstRegion *result; /* The returned Region pointer */ - int found; /* Has the current axis index been found yet? */ - int i; /* Axis index */ - int j; /* Index into the "axes" array */ - int nax; /* No. of base Frame axes */ - int ok; /* Are we doing a genuine axis permutation? */ - int unit; /* Is the axis permutation a unit map? */ - -/* Initialise */ - result = NULL; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the base Frame int he encapsulated FrameSet. */ - fr = astGetFrame( this->frameset, AST__BASE ); - -/* See how many axes it has. We only proceed if we are selecting all axes - in the base Frame. */ - nax = astGetNaxes( fr ); - if( nax == naxes ) { - -/* We now check that the axes array is a genuine permutation of all axes. - This means that all axis indices must occur once, and only once, within - the "axes" array. Look for each axis index in turn. */ - unit = 1; - ok = 1; - for( i = 0; i < nax && ok; i++ ) { - -/* Check each element of the axes array to see if it holds the axis index - currently being looked for. */ - found = 0; - for( j = 0; j < nax; j++ ) { - -/* If so, if this axis index has already been found, break out of the - loop. */ - if( axes[ j ] == i ) { - if( found ) { - ok = 0; - break; - } - found = 1; - -/* Note if we do not have a unit map (i.e. each axis is permuted onto itself). */ - if( i != j ) unit = 0; - } - } - -/* If the axis index was not found, we do not have a genuine axis - permutation. */ - if( !found ) ok = 0; - } - -/* If we have a genuine axis permutation, create a Region which is a copy - of the supplied region and set it to represent its base Frame. */ - if( ok ) { - result = astCopy( this ); - astSetRegFS( result, fr ); - -/* If the axis selection is not equivalent to a unit mapping, we now - permute the axes. */ - if( !unit ) astPermAxes( result, axes ); - } - } - -/* Free resources. */ - fr = astAnnul( fr ); - -/* Returned the result. */ - return result; -} - -static double *RegCentre( AstRegion *this, double *cen, double **ptr, - int index, int ifrm, int *status ){ -/* -*+ -* Name: -* astRegCentre - -* Purpose: -* Re-centre a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* double *astRegCentre( AstRegion *this, double *cen, double **ptr, -* int index, int ifrm ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function shifts the centre of the supplied Region to a -* specified position, or returns the current centre of the Region. - -* Parameters: -* this -* Pointer to the Region. -* cen -* Pointer to an array of axis values, giving the new centre. -* Supply a NULL value for this in order to use "ptr" and "index" to -* specify the new centre. -* ptr -* Pointer to an array of pointers, one for each axis in the Region. -* Each pointer locates an array of axis values. This is the format -* returned by the PointSet method astGetPoints. Only used if "cen" -* is NULL. -* index -* The index of the point within the arrays identified by "ptr" at -* which is stored the coords for the new centre position. Only used -* if "cen" is NULL. -* ifrm -* Should be AST__BASE or AST__CURRENT. Indicates whether the centre -* position is supplied and returned in the base or current Frame of -* the FrameSet encapsulated within "this". - -* Returned Value: -* If both "cen" and "ptr" are NULL then a pointer to a newly -* allocated dynamic array is returned which contains the centre -* coords of the Region. This array should be freed using astFree when -* no longer needed. If either of "ptr" or "cen" is not NULL, then a -* NULL pointer is returned. - -* Notes: -* - Any bad (AST__BAD) centre axis values are ignored. That is, the -* centre value on such axes is left unchanged. -* - Some Region sub-classes do not have a centre. Such classes will report -* an AST__INTER error code if this method is called with either "ptr" or -* "cen" not NULL. If "ptr" and "cen" are both NULL, then no error is -* reported if this method is invoked on a Region of an unsuitable class, -* but NULL is always returned. - -*- -*/ - -/* Local Variables: */ - double *result; - -/* Initialise */ - result = NULL; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* This abstract method must be over-ridden by each concrete sub-class - which allows the centre to be shifted. Report an error if this null - imlementation is called to set a new centre. If it is called to - enquire the current centre, then return a NULL pointer. */ - if( ptr || cen ) astError( AST__INTER, "astRegCentre(%s): The %s " - "class does not implement the astRegCentre method " - "inherited from the Region class (internal AST " - "programming error).", status, astGetClass( this ), - astGetClass( this ) ); - - return NULL; -} - -static void RegClearAttrib( AstRegion *this, const char *aattrib, - char **base_attrib, int *status ) { -/* -*+ -* Name: -* astRegClearAttrib - -* Purpose: -* Clear an attribute value for a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astRegClearAttrib( AstRegion *this, const char *aattrib, -* char **base_attrib ) - -* Class Membership: -* Region virtual function - -* Description: -* This function clears the value of a named attribute in both the base -* and current Frame in the FrameSet encapsulated within a Region, without -* remapping either Frame. -* -* No error is reported if the attribute is not recognised by the base -* Frame. - -* Parameters: -* this -* Pointer to the Region. -* aattrib -* Pointer to a null terminated string holding the attribute name. -* base_attrib -* Address of a location at which to return a pointer to the null -* terminated string holding the attribute name which was cleared in -* the base Frame of the encapsulated FrameSet. This may differ from -* the supplied attribute if the supplied attribute contains an axis -* index and the current->base Mapping in the FrameSet produces an -* axis permutation. The returned pointer should be freed using -* astFree when no longer needed. A NULL pointer may be supplied in -* which case no pointer is returned. -*- -*/ - -/* Local Variables: */ - AstFrame *frm; - AstMapping *junkmap; - AstMapping *map; - AstRegion *unc; - char *attrib; - char *battrib; - char buf1[ 100 ]; - int *outs; - int axis; - int baxis; - int i; - int len; - int nc; - int rep; - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Produce a lower case version of the attribute name string */ - nc = strlen( aattrib ); - attrib = astMalloc( nc + 1 ); - for( i = 0; i < nc; i++ ) attrib[ i ] = tolower( aattrib[ i ] ); - attrib[ nc ] = 0; - -/* Clear the attribute in the current Frame in the encapsulated FrameSet. - Use the protected astClearAttrib method which does not cause the Frame - to be remapped within the FrameSet. */ - frm = astGetFrame( this->frameset, AST__CURRENT ); - astClearAttrib( frm, attrib ); - frm = astAnnul( frm ); - -/* Indicate that we should use the supplied attribute name with the base Frame. */ - battrib = NULL; - -/* If the attribute name contains an axis number, we need to create a new - attribute name which refers to the corresponding base Frame axis - (since the base<->current Mapping may permute the axes). First parse the - supplied attribute name to locate any axis index. */ - len = strlen( attrib ); - if( nc = 0, ( 2 == astSscanf( attrib, "%[^(](%d) %n", buf1, &axis, - &nc ) ) && ( nc >= len ) ) { - -/* If found, convert the axis index from one-based to zero-based. */ - axis--; - -/* See if the specified current Frame axis is connected to one and only - one base Frame axis. If so, get the index of the base Frame axis. */ - map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE ); - outs = astMapSplit( map, 1, &axis, &junkmap ); - if( junkmap && astGetNout( junkmap ) == 1 ) { - baxis = outs[ 0 ]; - -/* If the base Frame axis index is different to the current Frame axis - index, create a new attribute name string using the base Frame axis index. */ - if( baxis != axis ) { - battrib = astMalloc( strlen( attrib ) + 10 ); - if( battrib ) sprintf( battrib, "%s(%d)", buf1, baxis + 1 ); - } - -/* If there is no one base Frame axis which corresponds to the supplied - current Frame axis, report an error. */ - } else if( astOK ) { - astError( AST__INTER, "astRegClearAttrib(%s): Unable to clear " - "attribute \"%s\" in the base Frame of the %s", status, - astGetClass( this ), attrib, astGetClass( this ) ); - astError( AST__INTER, "There is no base Frame axis corresponding " - "to current Frame axis %d\n", status, axis + 1 ); - } - -/* Free resources */ - outs = astFree( outs ); - if( junkmap ) junkmap = astAnnul( junkmap ); - map = astAnnul( map ); - } - -/* Clear the appropriate attribute name in the base Frame. This time ensure - that any error caused by the attribute name is annulled. Also clear it in - any uncertainty Region (the current Frame of the uncertainty Region is - assumed to be equivalent to the base Frame of the parent Region). */ - frm = astGetFrame( this->frameset, AST__BASE ); - if( frm ) { - rep = astReporting( 0 ); - astClearAttrib( frm, battrib ? battrib : attrib ); - if( astTestUnc( this ) ) { - unc = astGetUncFrm( this, AST__BASE ); - astRegClearAttrib( unc, battrib ? battrib : attrib, NULL ); - unc = astAnnul( unc ); - } - if( astStatus == AST__BADAT ) astClearStatus; - astReporting( rep ); - } - frm = astAnnul( frm ); - -/* If required return the modified base Frame attribute name. Otherwise, - free it. */ - if( base_attrib ) { - if( battrib ) { - *base_attrib = battrib; - } else { - *base_attrib = astStore( NULL, attrib, strlen( attrib ) + 1 ); - } - } else { - battrib = astFree( battrib ); - } - -/* Since the base Frame has been changed, any cached information calculated - on the basis of the base Frame properties may no longer be up to date. */ - astResetCache( this ); - -/* Free resources. */ - attrib = astFree( attrib ); - -} - -static AstPointSet *RegGrid( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astRegGrid - -* Purpose: -* Return a PointSet containing points spread through the volume of a -* Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astRegGrid( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a mesh of points spread -* throughout the volume of the Region. The points refer to the current -* Frame of the encapsulated FrameSet. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Pointer to the PointSet. The axis values in this PointSet will have -* associated accuracies derived from the uncertainties which were -* supplied when the Region was created. Annul the pointer using -* astAnnul when it is no longer needed. - -* Notes: -* - It should not be assumed that the returned points are evenly -* spaced withint he volume. -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables; */ - AstMapping *map; /* Base -> current Frame Mapping */ - AstPointSet *result; /* Pointer to returned PointSet */ - -/* Initialise the returned pointer */ - result = NULL; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* If the Region structure does not contain a pointer to a PointSet holding - positions evenly spread over the volume of the Region in the base - Frame, create one now. Note, we cannot cache the grid in the current - Frame in this way since the current Frame grid depends on the proprties - of the current Frame (e.g. System) which can be changed at any time. */ - if( !this->basegrid ) this->basegrid = astRegBaseGrid( this ); - -/* Get the simplified base->current Mapping */ - map = astRegMapping( this ); - -/* If the Mapping is a UnitMap, just return a clone of the PointSet - pointer stored in the Region structure. */ - if( astIsAUnitMap( map ) ){ - result = astClone( this->basegrid ); - -/* Otherwise, create a new PointSet holding the above points transformed - into the current Frame. */ - } else { - result = astTransform( map, this->basegrid, 1, NULL ); - } - -/* Free resources.*/ - map = astAnnul( map ); - -/* If an error has occurred, annul the returned PointSet. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -static AstPointSet *RegMesh( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astRegMesh - -* Purpose: -* Return a PointSet containing points spread over the boundary of a -* Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astRegMesh( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a PointSet containing a mesh of points on the -* boundary of the Region. The points refer to the current Frame of -* the encapsulated FrameSet. - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Pointer to the PointSet. The axis values in this PointSet will have -* associated accuracies derived from the uncertainties which were -* supplied when the Region was created. Annul the pointer using -* astAnnul when it is no longer needed. - -* Notes: -* - It should not be assumed that the returned points are evenly -* spaced on the boundary. -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. -*- -*/ - -/* Local Variables; */ - AstMapping *map; /* Base -> current Frame Mapping */ - AstPointSet *bmesh; /* Base Frame mesh */ - AstPointSet *result; /* Pointer to returned PointSet */ - -/* Initialise the returned pointer */ - result = NULL; - -/* Check the local error status. */ - if ( !astOK ) return result; - -/* Get a pointer to a PointSet holding positions evenly spread over the - boundary of the Region in the base Frame. */ - bmesh = astRegBaseMesh( this ); - -/* Get the simplified base->current Mapping */ - map = astRegMapping( this ); - -/* If the Mapping is a UnitMap, just return a clone of the mesh PointSet - pointer. */ - if( astIsAUnitMap( map ) ){ - result = astClone( bmesh ); - -/* Otherwise, create a new PointSet holding the above points transformed - into the current Frame. */ - } else { - result = astTransform( map, bmesh, 1, NULL ); - } - -/* Free resources.*/ - bmesh = astAnnul( bmesh ); - map = astAnnul( map ); - -/* If an error has occurred, annul the returned PointSet. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -static int RegDummyFS( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astRegDummyFS - -* Purpose: -* Check if a Region has a dummy FrameSet. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* int astRegDummyFS( AstRegion *this ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a flag indicating if the supplied Region has -* a dummy FrameSet. -* -* The astDump method for a Region may choose not to include the -* Region's FrameSet in the dump, depending on the value of the -* RegionFS attribute and the nature of the FrameSet. If the FrameSet -* is omitted from the Dump, then special action has to be taken when -* the dump is subsequently read in and used to re-create the Region. -* On encounterting such a dump, the astLoadRegion function will create -* a dummy FrameSet and associate it with the reconstructed Region. -* The new Region should not be used however until this dummy FrameSet -* has been replaced by the correct FrameSet. Performing this replacement -* is the responsibility of the parent class (i.e. the class which choose -* to omit the FrameSet from the dump). These will usually be Region -* classes which encapsulate other Regions, such as CmpRegion, Prism, -* Stc, etc. -* -* This function can be used by astLoad... methods in sub-classes to -* determine if a newly loaded component Region has a dummy FrameSet. If -* so the astLoad function should either use the astSetRegFS method to -* store a new FrameSet in the component Region. If the parent Region -* itself has a dummy FrameSet (i.e. is a component Region contained -* within a higher level Region) then it cannot do this and should -* ignore the presence of the dummy FrameSet (it then becomes the -* responsibility of hte parent Region to load appropriate FrameSets -* into all its components). - -* Parameters: -* this -* Pointer to the Region. - -* Returned Value: -* Non-zero if the Region has a dummy FrameSet. - -*- -*/ - -/* Check the inherited status. */ - if( !astOK ) return 0; - -/* The Ident attribute of the FrameSet will be set to DUMMY_FS if the - FrameSet is a dummy. */ - return !strcmp( astGetIdent( this->frameset ), DUMMY_FS ); -} - -static int RegPins( AstRegion *this, AstPointSet *pset, AstRegion *unc, - int **mask, int *status ){ -/* -*+ -* Name: -* astRegPins - -* Purpose: -* Check if a set of points fall on the boundary of a given Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* int astRegPins( AstRegion *this, AstPointSet *pset, AstRegion *unc, -* int **mask ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function returns a flag indicating if the supplied set of -* points all fall on the boundary of the given Region. -* -* Some tolerance is allowed, as specified by the uncertainty Region -* stored in the supplied Region "this", and the supplied uncertainty -* Region "unc" which describes the uncertainty of the supplied points. - -* Parameters: -* this -* Pointer to the Region. -* pset -* Pointer to the PointSet. The points are assumed to refer to the -* base Frame of the FrameSet encapsulated by "this". -* unc -* Pointer to a Region representing the uncertainties in the points -* given by "pset". The Region is assumed to represent the base Frame -* of the FrameSet encapsulated by "this". Zero uncertainity is assumed -* if NULL is supplied. -* mask -* Pointer to location at which to return a pointer to a newly -* allocated dynamic array of ints. The number of elements in this -* array is equal to the value of the Npoint attribute of "pset". -* Each element in the returned array is set to 1 if the -* corresponding position in "pset" is on the boundary of the Region -* and is set to zero otherwise. A NULL value may be supplied -* in which case no array is created. If created, the array should -* be freed using astFree when no longer needed. - -* Returned Value: -* Non-zero if the points all fall on the boundary of the given -* Region, to within the tolerance specified. Zero otherwise. - -*- -*/ - -/* Check the inherited status. */ - if( !astOK ) return 0; - -/* This abstract implementation simply reports an error. All sub-classes of - Region should over-ride this to return appropriate values. */ - astError( AST__INTER, "astRegPins(%s): The %s class does not implement " - "the astRegPins method inherited from the Region class " - "(internal AST programming error).", status, astGetClass( this ), - astGetClass( this ) ); - return 0; -} - -static void GetRegionBounds( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*++ -* Name: -c astGetRegionBounds -f AST_GETREGIONBOUNDS - -* Purpose: -* Returns the bounding box of Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astGetRegionBounds( AstRegion *this, double *lbnd, double *ubnd ) -f CALL AST_GETREGIONBOUNDS( THIS, LBND, UBND, STATUS ) - -* Class Membership: -* Region method. - -* Description: -c This function -f This routine -* returns the upper and lower limits of a box which just encompasses -* the supplied Region. The limits are returned as axis values within -* the Frame represented by the Region. The value of the Negated -* attribute is ignored (i.e. it is assumed that the Region has not -* been negated). - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c lbnd -f LBND() = DOUBLE PRECISION (Returned) -c Pointer to an -f An -* array in which to return the lower axis bounds covered by the Region. -* It should have at least as many elements as there are axes in the -* Region. If an axis has no lower limit, the returned value will -* be the largest possible negative value. -c ubnd -f UBND() = DOUBLE PRECISION (Returned) -c Pointer to an -f An -* array in which to return the upper axis bounds covered by the Region. -* It should have at least as many elements as there are axes in the -* Region. If an axis has no upper limit, the returned value will -* be the largest possible positive value. -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Notes: -* - The value of the Negated attribute is ignored (i.e. it is assumed that -* the Region has not been negated). -* - If an axis has no extent on an axis then the lower limit will be -* returned larger than the upper limit. Note, this is different to an -* axis which has a constant value (in which case both lower and upper -* limit will be returned set to the constant value). -* - If the bounds on an axis cannot be determined, AST__BAD is returned for -* both upper and lower bounds - -*-- -*/ - -/* Local Variables: */ - AstFrame *frm; /* Current Frame */ - AstMapping *smap; /* Simplified base -> current Mapping */ - AstPointSet *bmesh; /* PointSet holding base Frame mesh */ - AstPointSet *cmesh; /* PointSet holding current Frame mesh */ - double **bptr; /* Pointer to PointSet coord arrays */ - double **cptr; /* Pointer to PointSet coord arrays */ - double *blbnd; /* Lower bounds in base Frame */ - double *bubnd; /* Upper bounds in base Frame */ - double *p; /* Array of values for current axis */ - double width; /* Width of bounding box on i'th axis */ - int i; /* Axis count */ - int ip; /* Index of current corner */ - int j; /* Timer for low/high swaps */ - int jmax; /* Increment between low/high swaps */ - int lo; /* Assign low bound to next corner? */ - int nbase; /* Number of base Frame axes */ - int ncur; /* Number of current Frame axes */ - int npos; /* Number of box corners */ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Get the simplified base to current Mapping. */ - smap = astRegMapping( this ); - -/* If the simplified Mapping is a UnitMap, just store the base box bounds - in the returned arrays */ - if( astIsAUnitMap( smap ) ) { - astRegBaseBox( this, lbnd, ubnd ); - -/* Otherwise, we get a mesh of points over the boundary of the Region within - the base Frame, transform them into the current Frame, and find their bounds. */ - } else { - -/* If the Region is bounded, we can get a genuine mesh of points on the - boundary of the Region. */ - if( astGetBounded( this ) ) { - bmesh = astRegBaseMesh( this ); - -/* If the Region is not bounded, no mesh can be created so we use the - corners of the base frame bounding box instead. */ - } else { - -/* Get workspace to hold the bounds of the region within the base Frame. */ - nbase = astGetNin( smap ); - blbnd = astMalloc( sizeof( double )*nbase ); - bubnd = astMalloc( sizeof( double )*nbase ); - -/* Get the base Frame bounding box. */ - astRegBaseBox( this, blbnd, bubnd ); - -/* Get the number of corners in the base Frame bounding box. */ - npos = pow( 2, nbase ); - -/* Create a PointSet to hold the positions at the corners in the base - frame box. */ - bmesh = astPointSet( npos, nbase, " ", status ); - bptr = astGetPoints( bmesh ); - if( bptr ) { - -/* Store the coordinates of the box corners in the PointSet. */ - jmax = 1; - for( i = 0; i < nbase; i++ ) { - p = bptr[ i ]; - - lo = 1; - j = 0; - for( ip = 0; ip < npos; ip++,j++ ) { - if( j == jmax ) { - lo = 1 - lo; - j = 0; - } - p[ ip ] = lo ? blbnd[ i ] : bubnd[ i ]; - } - - jmax *= 2; - } - } - -/* Release resources. */ - blbnd = astFree( blbnd ); - bubnd = astFree( bubnd ); - } - -/* Create a new PointSet holding the above points transformed into the - current Frame. */ - cmesh = astTransform( smap, bmesh, 1, NULL ); - -/* There is a possibility that these points may span a singularity in the - coordinate system such as the RA=0 line in a SkyFrame. So ensure the - axis values are normalised into the shortest possible range. */ - frm = astGetFrame( this->frameset, AST__CURRENT ); - ncur = astGetNaxes( frm ); - - cptr = astGetPoints( cmesh ); - npos = astGetNpoint( cmesh ); - for( i = 0; i < ncur; i++ ) { - astAxNorm( frm, i+1, 1, npos, cptr[i] ); - } - -/* Get the axis bounds of this PointSet. */ - astBndPoints( cmesh, lbnd, ubnd ); - -/* There is again a possibility that these bounds may span a singularity in - the coordinate system such as the RA=0 line in a SkyFrame. So for each - axis we ensure the width (i.e. "ubnd-lbnd" ) is correct. */ - for( i = 0; i < ncur; i++ ) { - width = astAxDistance( frm, i + 1, lbnd[ i ], ubnd[ i ] ); - if( width != AST__BAD ) { - ubnd[ i ] = lbnd[ i ] + width; - } else { - ubnd[ i ] = AST__BAD; - lbnd[ i ] = AST__BAD; - } - } - -/* Release resources. */ - frm = astAnnul( frm ); - bmesh = astAnnul( bmesh ); - cmesh = astAnnul( cmesh ); - } - smap = astAnnul( smap ); -} - -static void GetRegionBounds2( AstRegion *this, double *lbnd, double *ubnd, int *status ){ -/* -*+ -* Name: -* astGetRegionBounds - -* Purpose: -* Returns the bounding box of Region. - -* Type: -* Protected virtual function. - -* Synopsis: -* #include "region.h" -* void astGetRegionBounds2( AstRegion *this, double *lbnd, double *ubnd ) - -* Class Membership: -* Region method. - -* Description: -* This function is like astGetRegionBounds, in that it returns the upper -* and lower limits of a box which just encompasses the supplied Region, -* as axis values within the Frame represented by the Region. But, in -* addition to assuming that the supplied Region has not been negated, it -* also assumes that any component Regions contained within the supplied -* Region have not been negated. - -* Parameters: -* this -* Pointer to the Region. -* lbnd -* Pointer to an array in which to return the lower axis bounds -* covered by the Region. It should have at least as many elements -* as there are axes in the Region. -* ubnd -* Pointer to an array in which to return the upper axis bounds -* covered by the Region. It should have at least as many elements -* as there are axes in the Region. - -* Notes: -* - The value of the Negated attribute is ignored (i.e. it is assumed that -* the Region has not been negated). The Nagated attributes of any -* component Regions are also ignored. - -*- -*/ - -/* Local Variables: */ - AstMapping *smap; /* Simplified base -> current Mapping */ - double *lbndb; /* Pointer to lower bounds on base box */ - double *ubndb; /* Pointer to upper bounds on base box */ - int i; /* Axis count */ - int nbase; /* Number of base Frame axes */ - int ncur; /* Number of current Frame axes */ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Find the number of axes in the base and current Frames of the - encapsulated FrameSet. */ - nbase = astGetNin( this->frameset ); - ncur = astGetNout( this->frameset ); - -/* Get the bounding box in the base Frame of the encapsulated FrameSet. */ - lbndb = astMalloc( sizeof( double )*(size_t) nbase ); - ubndb = astMalloc( sizeof( double )*(size_t) nbase ); - astRegBaseBox2( this, lbndb, ubndb ); - -/* Get the simplified base to current Mapping. */ - smap = astRegMapping( this ); - -/* Check pointers can be used safely. */ - if( smap ) { - -/* If the simplified Mapping is a UnitMap, just copy the base box bounds - to the returned arrays */ - if( astIsAUnitMap( smap ) ) { - for( i = 0; i < ncur; i++ ) { - lbnd[ i ] = lbndb[ i ]; - ubnd[ i ] = ubndb[ i ]; - } - -/* Otherwise, use astMapBox to find the corresponding current Frame - limits. */ - } else { - for( i = 0; i < ncur; i++ ) { - astMapBox( smap, lbndb, ubndb, 1, i, lbnd + i, ubnd + i, - NULL, NULL ); - } - } - } - -/* Release resources. */ - smap = astAnnul( smap ); - lbndb = astFree( lbndb ); - ubndb = astFree( ubndb ); -} - -static void GetRegionMesh( AstRegion *this, int surface, int maxpoint, - int maxcoord, int *npoint, double *points, - int *status ){ -/* -*++ -* Name: -c astGetRegionMesh -f AST_GETREGIONMESH - -* Purpose: -* Return a mesh of points covering the surface or volume of a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astGetRegionMesh( AstRegion *this, int surface, int maxpoint, -c int maxcoord, int *npoint, double *points ) -f CALL AST_GETREGIONMESH( THIS, SURFACE, MAXPOINT, MAXCOORD, NPOINT, -f POINTS, STATUS ) - -* Class Membership: -* Region method. - -* Description: -c This function -f This routine -* returns the axis values at a mesh of points either covering the -* surface (i.e. boundary) of the supplied Region, or filling the -* interior (i.e. volume) of the Region. The number of points in -* the mesh is approximately equal to the MeshSize attribute. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c surface -f SURFACE = LOGICAL (Given) -c If non-zero, -f If .TRUE., -* the returned points will cover the surface or the Region. -* Otherwise, they will fill the interior of the Region. -c maxpoint -f MAXPOINT = INTEGER (Given) -* If zero, the number of points in the mesh is returned in -c "*npoint", -f NPOINT, -* but no axis values are returned and all other parameters are ignored. -* If not zero, the supplied value should be the length of the -c second dimension of the "points" -f first dimension of the POINTS -* array. An error is reported if the number of points in the mesh -* exceeds this number. -c maxcoord -f MAXCOORD = INTEGER (Given) -* The length of the -c first dimension of the "points" array. -f second dimension of the POINTS array. -* An error is reported if the number of axes in the supplied Region -* exceeds this number. -c npoint -f NPOINT = INTEGER (Returned) -c A pointer to an integer in which to return the -f The -* number of points in the returned mesh. -c points -f POINTS( MAXPOINT, MAXCOORD ) = DOUBLE PRECISION (Returned) -c The address of the first element in a 2-dimensional array of -c shape "[maxcoord][maxpoint]", in which to return the coordinate -c values at the mesh positions. These are stored such that the -c value of coordinate number "coord" for point number "point" is -c found in element "points[coord][point]". -f An array in which to return the coordinates values at the mesh -f positions. These are stored such that the value of coordinate -f number COORD for point number POINT is found in element -f POINTS(POINT,COORD). -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Notes: -* - An error is reported if the Region is unbounded. -* - If the coordinate system represented by the Region has been -* changed since it was first created, the returned axis values refer -* to the new (changed) coordinate system, rather than the original -* coordinate system. Note however that if the transformation from -* original to new coordinate system is non-linear, the shape within -* the new coordinate system may be distorted, and so may not match -* that implied by the name of the Region subclass (Circle, Box, etc). - -*-- -*/ - -/* Local Variables: */ - AstPointSet *pset; /* PointSet holding mesh/grid axis values */ - double **ptr; /* Pointer to mesh/grid axes values */ - double *p; /* Pointer to next input axis value */ - double *q; /* Pointer to next output axis value */ - int j; /* Axis index */ - int nc; /* No. of axes to copy */ - -/* Initialise */ - *npoint = 0; - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Report an error if the Region is unbounded. */ - if( !astGetBounded( this ) ) { - if( astOK ) astError( AST__MBBNF, "astGetRegionMesh(%s): The supplied %s" - " is unbounded so no mesh can be created to cover " - "it.", status, astGetClass( this ), astGetClass( this ) ); - } else { - -/* Get the mesh or grid as required. If only the size of the mesh or grid - is required, get it in the base Frame as there is no need to spend the - extra time transforming it into the current Frame. */ - if( maxpoint == 0 ){ - if( surface ) { - pset = astRegBaseMesh( this ); - } else { - pset = astRegBaseGrid( this ); - } - } else { - if( surface ) { - pset = astRegMesh( this ); - } else { - pset = astRegGrid( this ); - } - } - -/* Return the number of points in the mesh or grid. */ - *npoint = astGetNpoint( pset ); - -/* Do nothing more unless a non-zero array size was supplied. */ - if( *npoint > 0 && maxpoint != 0 && astOK ) { - -/* Check the supplied array is large enough. */ - if( *npoint > maxpoint ) { - astError( AST__DIMIN, "astGetRegionMesh(%s): The supplied " - "array can hold up to %d points but the %s supplied " - "has %d points on its mesh (programming error).", - status, astGetClass( this ), maxpoint, astGetClass( this ), - *npoint ); - } - -/* Get the dimensionality of the PointSet, and get a pointer to the axis - values. */ - nc = astGetNcoord( pset ); - ptr = astGetPoints( pset ); - -/* Check pointers can be used safely. */ - if ( astOK ) { - -/* Check the supplied array has room for all the axes. */ - if( nc > maxcoord ) { - astError( AST__DIMIN, "astGetRegionMesh(%s): The supplied " - "array can hold up to %d axes but the %s supplied " - "has %d axes (programming error).", status, - astGetClass( this ), maxcoord, astGetClass( this ), nc ); - -/* If all is OK, copy the current Frame axis values into the supplied array. */ - } else { - -/* Loop round the axes to be copied. */ - for( j = 0; j < nc; j++ ) { - -/* Get points to the first element of the input and output arrays. */ - p = ptr[ j ]; - q = points + j*maxpoint; - -/* Copying the axis values. */ - (void) memcpy( q, p, sizeof( double )*( *npoint ) ); - } - } - } - } - -/* Free resources. */ - pset = astAnnul( pset ); - } -} - -static void GetRegionPoints( AstRegion *this, int maxpoint, int maxcoord, - int *npoint, double *points, int *status ){ -/* -*++ -* Name: -c astGetRegionPoints -f AST_GETREGIONPOINTS - -* Purpose: -* Returns the positions that define the given Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astGetRegionPoints( AstRegion *this, int maxpoint, int maxcoord, -c int *npoint, double *points ) -f CALL AST_GETREGIONPOINTS( THIS, MAXPOINT, MAXCOORD, NPOINT, POINTS, -f STATUS ) - -* Class Membership: -* Region method. - -* Description: -c This function -f This routine -* returns the axis values at the points that define the supplied -* Region. The particular meaning of these points will depend on the -* type of class supplied, as listed below under "Applicability:". - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c maxpoint -f MAXPOINT = INTEGER (Given) -* If zero, the number of points needed to define the Region is -* returned in -c "*npoint", -f NPOINT, -* but no axis values are returned and all other parameters are ignored. -* If not zero, the supplied value should be the length of the -c second dimension of the "points" -f first dimension of the POINTS -* array. An error is reported if the number of points needed to define -* the Region exceeds this number. -c maxcoord -f MAXCOORD = INTEGER (Given) -* The length of the -c first dimension of the "points" array. -f second dimension of the POINTS array. -* An error is reported if the number of axes in the supplied Region -* exceeds this number. -c npoint -f NPOINT = INTEGER (Returned) -c A pointer to an integer in which to return the -f The -* number of points defining the Region. -c points -f POINTS( MAXPOINT, MAXCOORD ) = DOUBLE PRECISION (Returned) -c The address of the first element in a 2-dimensional array of -c shape "[maxcoord][maxpoint]", in which to return -c the coordinate values at the positions that define the Region. -c These are stored such that the value of coordinate number -c "coord" for point number "point" is found in element -c "points[coord][point]". -f An array in which to return the coordinates values at the -f positions that define the Region. These are stored such that the -f value of coordinate number COORD for point number POINT -f is found in element POINTS(POINT,COORD). -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Applicability: -* Region -* All Regions have this attribute. -* Box -* The first returned position is the Box centre, and the second is -* a Box corner. -* Circle -* The first returned position is the Circle centre, and the second is -* a point on the circumference. -* CmpRegion -* Returns a value of zero for -c "*npoint" -f NPOINT -* and leaves the supplied array contents unchanged. To find the -* points defining a CmpRegion, use this method on the component -* Regions, which can be accessed by invoking -c astDecompose -f AST_DECOMPOSE -* on the CmpRegion. -* Ellipse -* The first returned position is the Ellipse centre. The second is -* the end of one of the axes of the ellipse. The third is some -* other point on the circumference of the ellipse, distinct from -* the second point. -* Interval -* The first point corresponds to the lower bounds position, and -* the second point corresponds to the upper bounds position. These -* are reversed to indicate an extcluded interval rather than an -* included interval. See the Interval constructor for more -* information. -* NullRegion -* Returns a value of zero for -c "*npoint" -f NPOINT -* and leaves the supplied array contents unchanged. -* PointList -* The positions returned are those that were supplied when the -* PointList was constructed. -* Polygon -* The positions returned are the vertex positions that were supplied -* when the Polygon was constructed. -* Prism -* Returns a value of zero for -c "*npoint" -f NPOINT -* and leaves the supplied array contents unchanged. To find the -* points defining a Prism, use this method on the component -* Regions, which can be accessed by invoking -c astDecompose -f AST_DECOMPOSE -* on the CmpRegion. - -* Notes: -* - If the coordinate system represented by the Region has been -* changed since it was first created, the returned axis values refer -* to the new (changed) coordinate system, rather than the original -* coordinate system. Note however that if the transformation from -* original to new coordinate system is non-linear, the shape within -* the new coordinate system may be distorted, and so may not match -* that implied by the name of the Region subclass (Circle, Box, etc). - -*-- -*/ - -/* Local Variables: */ - AstPointSet *pset; /* PointSet holding PointList axis values */ - double **ptr; /* Pointer to axes values in the PointList */ - double *p; /* Pointer to next input axis value */ - double *q; /* Pointer to next output axis value */ - int j; /* Axis index */ - int nc; /* No. of axes to copy */ - -/* Initialise */ - *npoint = 0; - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Return the number of points used to define the Region, if any. */ - *npoint = this->points ? astGetNpoint( this->points ) : 0; - -/* Do nothing more unless a non-zero array size was supplied. */ - if( *npoint > 0 && maxpoint != 0 ) { - -/* Transform the base Frame axis values into the current Frame. */ - pset = astTransform( this->frameset, this->points, 1, NULL ); - -/* Get the dimensionality of this PointList, and get a pointer to the axis - values. */ - nc = astGetNcoord( pset ); - ptr = astGetPoints( pset ); - -/* Check pointers can be used safely. */ - if ( astOK ) { - -/* Check the supplied array has room for all the axis values. */ - if( nc > maxcoord ) { - astError( AST__DIMIN, "astGetRegionPoints(%s): The supplied " - "array can hold up to %d axes but the %s supplied " - "has %d axes (programming error).", status, - astGetClass( this ), maxcoord, astGetClass( this ), nc ); - - } else if( *npoint > maxpoint ) { - astError( AST__DIMIN, "astGetRegionPoints(%s): The supplied " - "array can hold up to %d points but the %s supplied " - "requires %d points to describe it (programming " - "error).", status, astGetClass( this ), maxpoint, - astGetClass( this ), *npoint ); - -/* If all is OK, copy the transformed axis values into the supplied array. */ - } else { - -/* Loop round the axes to be copied. */ - for( j = 0; j < nc; j++ ) { - -/* Get points to the first element of the input and output arrays. */ - p = ptr[ j ]; - q = points + j*maxpoint; - -/* Copying the axis values. */ - (void) memcpy( q, p, sizeof( double )*( *npoint ) ); - } - } - } - -/* Free resources. */ - pset = astAnnul( pset ); - - } -} - -static void RegOverlay( AstRegion *this, AstRegion *that, int unc, int *status ){ -/* -*+ -* Name: -* astRegOverlay - -* Purpose: -* Copy properties from one Region to another. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astRegOverlay( AstRegion *this, AstRegion *that, int unc ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function copies selected properties from "that" to "this". -* It is intended to be called by sub-classes which need to create a -* similar copy of an existing Region. For instance, subclass -* implementations of the Simplify method will usually use this -* function to ensure that the simplified Region loooks like the original -* Region. - -* Parameters: -* this -* Pointer to the new Region. -* that -* Pointer to the old Region. -* unc -* If non-zero, any uncertainty in "this" is cleared if "that" has -* no uncertainty. If zero, any uncertainty in "this" is left -* unchanged. -*- -*/ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Copy the required attribute values. */ - this->negated = that->negated; - this->closed = that->closed; - this->regionfs = that->regionfs; - this->adaptive = that->adaptive; - -/* Clear things that depend on the number of axes. */ - if( astGetNaxes( this ) == astGetNaxes( that ) ) { - if( astTestMeshSize( that ) ) astSetMeshSize( this, astGetMeshSize( that ) ); - if( astTestFillFactor( that ) ) astSetFillFactor( this, astGetFillFactor( that ) ); - } else { - astClearMeshSize( this ); - astClearFillFactor( this ); - } - -/* If required, clear uncertainty in "this" if "that" has no uncertainty. */ - if( unc && !astTestUnc( that ) ) astClearUnc( this ); - -} - -static void RegSetAttrib( AstRegion *this, const char *asetting, - char **base_setting, int *status ) { -/* -*+ -* Name: -* astRegSetAttrib - -* Purpose: -* Set an attribute value for a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astRegSetAttrib( AstRegion *this, const char *asetting, -* char **base_setting ) - -* Class Membership: -* Region virtual function - -* Description: -* This function assigns an attribute value to both the base and -* current Frame in the FrameSet encapsulated within a Region, without -* remapping either Frame. -* -* No error is reported if the attribute is not recognised by the base -* Frame. - -* Parameters: -* this -* Pointer to the Region. -* asetting -* Pointer to a null terminated attribute setting string. The supplied -* string will be interpreted using the public interpretation -* implemented by astSetAttrib. This can be different to the -* interpretation of the protected accessor functions. For instance, -* the public interpretation of an unqualified floating point value for -* the Epoch attribute is to interpet the value as a gregorian year, -* but the protected interpretation is to interpret the value as an -* MJD. -* base_setting -* Address of a location at which to return a pointer to the null -* terminated attribute setting string which was applied to the -* base Frame of the encapsulated FrameSet. This may differ from -* the supplied setting if the supplied setting contains an axis -* index and the current->base Mapping in the FrameSet produces an -* axis permutation. The returned pointer should be freed using -* astFree when no longer needed. A NULL pointer may be supplied in -* which case no pointer is returned. -*- -*/ - -/* Local Variables: */ - AstFrame *frm; - AstMapping *junkmap; - AstMapping *map; - AstRegion *unc; - char *setting; - char *bsetting; - char buf1[ 100 ]; - int *outs; - int axis; - int baxis; - int i; - int len; - int nc; - int rep; - int value; - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Produce a lower case version of the setting string */ - nc = strlen( asetting ); - setting = astMalloc( nc + 1 ); - for( i = 0; i < nc; i++ ) setting[ i ] = tolower( asetting[ i ] ); - setting[ nc ] = 0; - -/* Apply the setting to the current Frame in the encapsulated FrameSet. - Use the protected astSetAttrib method which does not cause the Frame - to be remapped within the FrameSet. */ - frm = astGetFrame( this->frameset, AST__CURRENT ); - astSetAttrib( frm, setting ); - frm = astAnnul( frm ); - -/* Indicate that we should use the supplied setting with the base Frame. */ - bsetting = NULL; - -/* If the attribute name contains an axis number, we need to create a new - attribute setting which refers to the corresponding base Frame axis - (since the base<->current Mapping may permute the axes). First parse the - supplied attribute setting to locate any axis index. */ - len = strlen( setting ); - if( nc = 0, ( 2 == astSscanf( setting, "%[^(](%d)= %n%*s %n", buf1, &axis, - &value, &nc ) ) && ( nc >= len ) ) { - -/* If found, convert the axis index from one-based to zero-based. */ - axis--; - -/* See if the specified current Frame axis is connected to one and only - one base Frame axis. If so, get the index of the base Frame axis. */ - map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE ); - outs = astMapSplit( map, 1, &axis, &junkmap ); - if( junkmap && astGetNout( junkmap ) == 1 ) { - baxis = outs[ 0 ]; - -/* If the base Frame axis index is different to the current Frame axis - index, create a new setting string using the base Frame axis index. */ - if( baxis != axis ) { - bsetting = astMalloc( strlen( setting ) + 10 ); - if( bsetting ) { - sprintf( bsetting, "%s(%d)=%s", buf1, baxis + 1, setting + value ); - } - } - -/* If there is no one base Frame axis which corresponds to the supplied - current Frame axis, report an error. */ - } else if( astOK ) { - astError( AST__INTER, "astRegSetAttrib(%s): Unable to apply " - "attribute setting \"%s\" to the base Frame in the %s", status, - astGetClass( this ), setting, astGetClass( this ) ); - astError( AST__INTER, "There is no base Frame axis corresponding " - "to current Frame axis %d\n", status, axis + 1 ); - } - -/* Free resources */ - outs = astFree( outs ); - if( junkmap ) junkmap = astAnnul( junkmap ); - map = astAnnul( map ); - } - -/* Apply the appropriate attribute setting to the base Frame. This time - ensure that any error caused by the attribute setting is annulled. - Also apply it to any uncertainty Region (the current Frame of the - uncertainty Region is assumed to be equivalent to the base Frame of the - parent Region). */ - frm = astGetFrame( this->frameset, AST__BASE ); - if( frm ) { - rep = astReporting( 0 ); - astSetAttrib( frm, bsetting ? bsetting : setting ); - if( astTestUnc( this ) ) { - unc = astGetUncFrm( this, AST__BASE ); - astRegSetAttrib( unc, bsetting ? bsetting : setting, NULL ); - unc = astAnnul( unc ); - } - if( astStatus == AST__BADAT ) astClearStatus; - astReporting( rep ); - } - frm = astAnnul( frm ); - -/* If required return the modified base Frame setting. Otherwise, free it. */ - if( base_setting ) { - if( bsetting ) { - *base_setting = bsetting; - } else { - *base_setting = astStore( NULL, setting, strlen( setting ) + 1 ); - } - } else { - bsetting = astFree( bsetting ); - } - -/* Since the base Frame has been changed, any cached information calculated - on the basis of the base Frame properties may no longer be up to date. */ - astResetCache( this ); - -/* Free resources. */ - setting = astFree( setting ); - -} - -static AstMapping *RemoveRegions( AstMapping *this_mapping, int *status ) { -/* -* Name: -* RemoveRegions - -* Purpose: -* Remove any Regions from a Mapping. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstMapping *RemoveRegions( AstMapping *this, int *status ) - -* Class Membership: -* Region method (over-rides the astRemoveRegions method inherited -* from the Frame class). - -* Description: -* This function searches the supplied Mapping (which may be a -* compound Mapping such as a CmpMap) for any component Mappings -* that are instances of the AST Region class. It then creates a new -* Mapping from which all Regions have been removed. If a Region -* cannot simply be removed (for instance, if it is a component of a -* parallel CmpMap), then it is replaced with an equivalent UnitMap -* in the returned Mapping. -* -* The implementation provided by the Region class just returns the -* equivalent Frame. - -* Parameters: -* this -* Pointer to the original Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer to the modified mapping. - -* Notes: -* - A NULL pointer value will be returned if this function is -* invoked with the AST error status set, or if it should fail for -* any reason. -*/ - -/* The Region class just returns a pointer to a deep copy of the Region's - equivalent Frame. */ - return astGetRegionFrame( (AstRegion *)this_mapping ); -} - -static void ReportPoints( AstMapping *this_mapping, int forward, - AstPointSet *in_points, AstPointSet *out_points, int *status ) { -/* -* Name: -* ReportPoints - -* Purpose: -* Report the effect of transforming a set of points using a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void ReportPoints( AstMapping *this, int forward, -* AstPointSet *in_points, AstPointSet *out_points, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astReportPoints -* method inherited from the Frame class). - -* Description: -* This function reports the coordinates of a set of points before -* and after being transformed by a Region, by writing them to -* standard output. - -* Parameters: -* this -* Pointer to the Region. -* forward -* A non-zero value indicates that the Region's forward -* coordinate transformation has been applied, while a zero -* value indicates the inverse transformation. -* in_points -* Pointer to a PointSet which is associated with the -* coordinates of a set of points before the Region was -* applied. -* out_points -* Pointer to a PointSet which is associated with the -* coordinates of the same set of points after the Region has -* been applied. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_mapping; - -/* Obtain a pointer to the Region's current Frame and invoke its - astReportPoints method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astReportPoints( (AstMapping *) fr, forward, in_points, out_points ); - fr = astAnnul( fr ); - -} - -static void ResetCache( AstRegion *this, int *status ){ -/* -*+ -* Name: -* astResetCache - -* Purpose: -* Clear cached information within the supplied Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astResetCache( AstRegion *this ) - -* Class Membership: -* Region virtual function - -* Description: -* This function clears cached information from the supplied Region -* structure. - -* Parameters: -* this -* Pointer to the Region. -*- -*/ - if( this ) { - if( this->basemesh ) this->basemesh = astAnnul( this->basemesh ); - if( this->basegrid ) this->basegrid = astAnnul( this->basegrid ); - if( this->negation ) this->negation = astAnnul( this->negation ); - } -} - - -static void Resolve( AstFrame *this_frame, const double point1[], - const double point2[], const double point3[], - double point4[], double *d1, double *d2, int *status ){ -/* -* Name: -* Resolve - -* Purpose: -* Resolve a vector into two orthogonal components - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void Resolve( AstFrame *this, const double point1[], -* const double point2[], const double point3[], -* double point4[], double *d1, double *d2, int *status ); - -* Class Membership: -* Region member function (over-rides the protected astResolve -* method inherited from the Frame class). - -* Description: -* This function resolves a vector into two perpendicular components. -* The vector from point 1 to point 2 is used as the basis vector. -* The vector from point 1 to point 3 is resolved into components -* parallel and perpendicular to this basis vector. The lengths of the -* two components are returned, together with the position of closest -* aproach of the basis vector to point 3. - -* Parameters: -* this -* Pointer to the Frame. -* point1 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This marks the start of the basis vector, -* and of the vector to be resolved. -* point2 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This marks the end of the basis vector. -* point3 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This marks the end of the vector to be -* resolved. -* point4 -* An array of double, with one element for each Frame axis -* in which the coordinates of the point of closest approach of the -* basis vector to point 3 will be returned. -* d1 -* The address of a location at which to return the distance from -* point 1 to point 4 (that is, the length of the component parallel -* to the basis vector). Positive values are in the same sense as -* movement from point 1 to point 2. -* d2 -* The address of a location at which to return the distance from -* point 4 to point 3 (that is, the length of the component -* perpendicular to the basis vector). The value is always positive. -* status -* Pointer to the inherited status variable. - -* Notes: -* - Each vector used in this function is the path of -* shortest distance between two points, as defined by the -* astDistance function. -* - This function will return "bad" coordinate values (AST__BAD) -* if any of the input coordinates has this value, or if the required -* output values are undefined. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke this - Frame's astResolve method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astResolve( fr, point1, point2, point3, point4, d1, d2 ); - fr = astAnnul( fr ); - -} - -static AstPointSet *ResolvePoints( AstFrame *this_frame, const double point1[], - const double point2[], AstPointSet *in, - AstPointSet *out, int *status ) { -/* -* Name: -* ResolvePoints - -* Purpose: -* Resolve a set of vectors into orthogonal components - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstPointSet *ResolvePoints( AstFrame *this, const double point1[], -* const double point2[], AstPointSet *in, -* AstPointSet *out ) - -* Class Membership: -* Region member function (over-rides the astResolvePoints method -* inherited from the Frame class). - -* Description: -* This function takes a Frame and a set of vectors encapsulated -* in a PointSet, and resolves each one into two orthogonal components, -* returning these two components in another PointSet. -* -* This is exactly the same as the public astResolve method, except -* that this method allows many vectors to be processed in a single call, -* thus reducing the computational cost of overheads of many -* individual calls to astResolve. - -* Parameters: -* this -* Pointer to the Frame. -* point1 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This marks the start of the basis vector, -* and of the vectors to be resolved. -* point2 -* An array of double, with one element for each Frame axis -* (Naxes attribute). This marks the end of the basis vector. -* in -* Pointer to the PointSet holding the ends of the vectors to be -* resolved. -* out -* Pointer to a PointSet which will hold the length of the two -* resolved components. A NULL value may also be given, in which -* case a new PointSet will be created by this function. - -* Returned Value: -* Pointer to the output (possibly new) PointSet. The first axis will -* hold the lengths of the vector components parallel to the basis vector. -* These values will be signed (positive values are in the same sense as -* movement from point 1 to point 2. The second axis will hold the lengths -* of the vector components perpendicular to the basis vector. These -* values will always be positive. - -* Notes: -* - The number of coordinate values per point in the input -* PointSet must match the number of axes in the supplied Frame. -* - If an output PointSet is supplied, it must have space for -* sufficient number of points and 2 coordinate values per point. -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstPointSet *result; /* Pointer to output PointSet */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke this - Frame's astResolve method. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astResolvePoints( fr, point1, point2, in, out ); - fr = astAnnul( fr ); - -/* Return a pointer to the output PointSet. */ - return result; - -} - -static void SetAttrib( AstObject *this_object, const char *setting, int *status ) { -/* -* Name: -* SetAttrib - -* Purpose: -* Set an attribute value for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void SetAttrib( AstObject *this, const char *setting, int *status ) - -* Class Membership: -* Region member function (extends the astSetAttrib method -* inherited from the Frame class). - -* Description: -* This function assigns an attribute value for a Region, the -* attribute and its value being specified by means of a string of -* the form: -* -* "attribute= value " -* -* Here, "attribute" specifies the attribute name and should be in -* lower case with no white space present. The value to the right -* of the "=" should be a suitable textual representation of the -* value to be assigned and this will be interpreted according to -* the attribute's data type. White space surrounding the value is -* only significant for string attributes. - -* Parameters: -* this -* Pointer to the Region. -* setting -* Pointer to a null terminated string specifying the new -* attribute value. -* status -* Pointer to the inherited status variable. - -* Notes: -* - This protected method is intended to be invoked by the Object -* astSet method and makes additional attributes accessible to it. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to the Region structure */ - double dval; /* Floating point attribute value */ - int ival; /* Integer attribute value */ - int id; /* Offset of ID string */ - int len; /* Length of setting string */ - int nc; /* Number of characters read by astSscanf */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* Obtain the length of the setting string. */ - len = strlen( setting ); - -/* Test for each recognised attribute in turn, using "astSscanf" to parse the - setting string and extract the attribute value (or an offset to it in the - case of string values). In each case, use the value set in "nc" to check - that the entire string was matched. Once a value has been obtained, use the - appropriate method to set it. */ - -/* We first handle attributes that apply to the Region as a whole - (rather than to the encapsulated Frame). */ - -/* Negated */ -/* ------- */ - if ( nc = 0, - ( 1 == astSscanf( setting, "negated= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetNegated( this, ival ); - -/* Closed */ -/*------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "closed= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetClosed( this, ival ); - -/* FillFactor */ -/* ---------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "fillfactor= %lg %n", &dval, &nc ) ) - && ( nc >= len ) ) { - astSetFillFactor( this, dval ); - -/* MeshSize */ -/* -------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "meshsize= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetMeshSize( this, ival ); - -/* Adaptive */ -/* -------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "adaptive= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetAdaptive( this, ival ); - -/* Now do attributes inherited from parent classes. We do these here to - avoid the settings being passed on to the encapsulated FrameSet below. */ - -/* ID. */ -/* --- */ - } else if ( nc = 0, ( 0 == astSscanf( setting, "id=%n%*[^\n]%n", &id, &nc ) ) - && ( nc >= len ) ) { - astSetID( this, setting + id ); - -/* Ident. */ -/* ------ */ - } else if ( nc = 0, ( 0 == astSscanf( setting, "ident=%n%*[^\n]%n", &id, &nc ) ) - && ( nc >= len ) ) { - astSetIdent( this, setting + id ); - -/* Invert. */ -/* ------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "invert= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetInvert( this, ival ); - -/* Report. */ -/* ------- */ - } else if ( nc = 0, - ( 1 == astSscanf( setting, "report= %d %n", &ival, &nc ) ) - && ( nc >= len ) ) { - astSetReport( this, ival ); - -/* Define macros to see if the setting string matches any of the - read-only attributes of this class. */ -#define MATCH(attrib) \ - ( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \ - ( nc >= len ) ) - -#define AXISMATCH(attrib) \ - ( nc = 0, ( 0 == astSscanf( setting, attrib "(%*d)=%*[^\n]%n", &nc ) ) && \ - ( nc >= len ) ) - -/* If the attribute was not recognised, use this macro to report an error - if a read-only attribute has been specified. */ - } else if ( MATCH( "class" ) || - MATCH( "nin" ) || - MATCH( "nobject" ) || - MATCH( "bounded" ) || - MATCH( "nout" ) || - MATCH( "refcount" ) || - MATCH( "tranforward" ) || - MATCH( "traninverse" ) ) { - astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status, - setting, astGetClass( this ) ); - astError( AST__NOWRT, "This is a read-only attribute." , status); - -/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for - further interpretation. Do not pass on FrameSet attributes since we - pretend to the outside world that the encapsulated FrameSet is actually a - Frame. */ - } else if ( !MATCH( "base" ) && - !MATCH( "current" ) && - !MATCH( "nframe" ) ) { - -/* If the Region is to adapt to coordinate system chanmges, use the public - astSet method so that the current Frame in the encapsulated FrameSet will - be re-mapped if the attribute changes require it. */ - if( astGetAdaptive( this ) ) { - astSet( this->frameset, setting, status ); - -/* If the Region is not to adapt to coordinate system chanmges, use the - astRegSetAttrib method which assigns the attribute setting to both - current and base Frames in the FrameSet without causing any remapping to - be performed. */ - } else { - astRegSetAttrib( this, setting, NULL ); - } - } - -/* Undefine macros local to this function. */ -#undef MATCH -} - -static void SetAxis( AstFrame *this_frame, int axis, AstAxis *newaxis, int *status ) { -/* -* Name: -* SetAxis - -* Purpose: -* Set a new Axis for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void SetAxis( AstFrame *this, int axis, AstAxis *newaxis, int *status ) - -* Class Membership: -* Region member function (over-rides the astSetAxis method -* inherited from the Frame class). - -* Description: -* This function allows a new Axis object to be associated with one -* of the axes of the current Frame in a Region, replacing the -* previous one. Each Axis object contains a description of the -* quantity represented along one of the Frame's axes, so this -* function allows this description to be exchanged for another -* one. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The index (zero-based) of the axis whose associated Axis -* object is to be replaced. -* newaxis -* Pointer to the new Axis object. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index supplied. */ - (void) astValidateAxis( this, axis, 1, "astSetAxis" ); - -/* Obtain a pointer to the Region's current Frame and invoke this - Frame's astSetAxis method to assign the new Axis object. Annul the - Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astSetAxis( fr, axis, newaxis ); - fr = astAnnul( fr ); -} - -static void SetRegFS( AstRegion *this, AstFrame *frm, int *status ) { -/* -*+ -* Name: -* astSetRegFS - -* Purpose: -* Stores a new FrameSet in a Region - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* void astSetRegFS( AstRegion *this, AstFrame *frm ) - -* Class Membership: -* Region virtual function. - -* Description: -* This function creates a new FrameSet and stores it in the supplied -* Region. The new FrameSet contains two copies of the supplied -* Frame, connected by a UnitMap. - -* Parameters: -* this -* Pointer to the Region. -* frm -* The Frame to use. -*- -*/ - -/* Local Variables: */ - AstFrame *f1; /* Copy of supplied Frame */ - AstFrame *f2; /* Copy of supplied Frame */ - AstFrameSet *fs; /* New FrameSet */ - AstRegion *unc; /* Uncertainty Region */ - AstUnitMap *um; /* UnitMap connecting base anc current Frames */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Take a copy of the supplied Frame. */ - f1 = astCopy( frm ); - -/* Create the new FrameSet. First take another copy of the supplied Frame - so that modifications using the supplied pointer will not affect the new - FrameSet. We create two copies (rather than 1) because the base and - current Frames must be independant objects - otherwise attribute changes - done to one will also appear in the other. Then construct the FrameSet - containing the two Frame copies connected by a UnitMap. */ - f2 = astCopy( f1 ); - fs = astFrameSet( f1, "", status ); - um = astUnitMap( astGetNaxes( f1 ), "", status ); - astAddFrame( fs, AST__BASE, um, f2 ); - um = astAnnul( um ); - f2 = astAnnul( f2 ); - -/* Annul any existing FrameSet */ - if( this->frameset ) (void) astAnnul( this->frameset ); - -/* Use the new FrameSet */ - this->frameset = fs; - -/* If any uncertainty Region has a zero value for its RegionFS attribute, - it will currently contain a dummy FrameSet rather than the correct - FrameSet. The correct FrameSet has copies of the base Frame of the new - Region as both its current and base Frames, and these are connected by - a UnitMap (this is equivalent to a FrameSet containing a single Frame). */ - if( astTestUnc( this ) ) { - unc = astGetUncFrm( this, AST__BASE ); - if( unc && !astGetRegionFS( unc ) ) astSetRegFS( unc, f1 ); - unc = astAnnul( unc ); - } - -/* Free remaining resourvces */ - f1 = astAnnul( f1 ); - -} - -static void SetUnc( AstRegion *this, AstRegion *unc, int *status ){ -/* -*++ -* Name: -c astSetUnc -f AST_SETUNC - -* Purpose: -* Store uncertainty information in a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astSetUnc( AstRegion *this, AstRegion *unc ) -f CALL AST_SETUNC( THIS, UNC, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* Each Region (of any class) can have an "uncertainty" which specifies -* the uncertainties associated with the boundary of the Region. This -* information is supplied in the form of a second Region. The uncertainty -* in any point on the boundary of a Region is found by shifting the -* associated "uncertainty" Region so that it is centred at the boundary -* point being considered. The area covered by the shifted uncertainty -* Region then represents the uncertainty in the boundary position. -* The uncertainty is assumed to be the same for all points. -* -* The uncertainty is usually specified when the Region is created, but -* this -c function -f routine -* allows it to be changed at any time. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region which is to be assigned a new uncertainty. -c unc -f UNC = INTEGER (Given) -* Pointer to the new uncertainty Region. This must be of a class for -* which all instances are centro-symetric (e.g. Box, Circle, Ellipse, -* etc.) or be a Prism containing centro-symetric component Regions. -* A deep copy of the supplied Region will be taken, so subsequent -* changes to the uncertainty Region using the supplied pointer will -* have no effect on the Region -c "this". -f THIS. -f STATUS = INTEGER (Given and Returned) -f The global status. - -*-- -*/ - -/* Local Variables: */ - AstFrame *frm; /* Current Frame from FrameSet */ - AstFrameSet *fs2; /* FrameSet from "unc" current Frame to "this" base Frame */ - AstFrameSet *fs; /* FrameSet in "this" supplied Region */ - AstMapping *map2; /* Base->current Mapping from FrameSet */ - AstMapping *map; /* Base->current Mapping from FrameSet */ - AstMapping *smap; /* Simplified base->current Mapping */ - double *cen0; /* Pointer to array holding original centre */ - double **ptr_reg; /* Pointer to axis values for Region's Pointset */ - int changed; /* Has the uncertainty been changed? */ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Annul any existing uncertainty Region. */ - if( this->unc ) { - this->unc = astIsAObject( this->unc ) ? - astAnnul( this->unc ) : NULL; - changed = 1; - } else { - changed = 0; - } - -/* Check an uncertainty Region was supplied, and is of a usable class - (i.e. a class which can be re-centred). */ - cen0 = unc ? astRegCentre( unc, NULL, NULL, 0, 0 ) : NULL; - if( cen0 ) { - cen0 = astFree( cen0 ); - -/* Map it into the same Frame as that represented by the base Frame in - the supplied Region. */ - fs = this->frameset; - astInvert( fs ); - fs2 = Conv( unc->frameset, fs, status ); - astInvert( fs ); - - if( fs2 ) { - map = astGetMapping( fs2, AST__BASE, AST__CURRENT ); - frm = astGetFrame( fs2, AST__CURRENT ); - this->unc = astMapRegion( unc, map, frm ); - if( this->unc ) { - -/* Ensure the Region is bounded. We know that negating an unbounded - Region will make it bounded because we know that the Region consists of - Circles, Boxes and/or Ellipses, all of which have this property. */ - if( !astGetBounded( this->unc ) ) astNegate( this->unc ); - -/* If the base Frame in the uncertainty Region is the same as the base - Frame in the Region being dumped, then we do no need to include the - FrameSet in the dump of the uncertainty Region. Since the current - Frame in the uncertainty Region always corresponds to the base Frame of - its parent Region, we only need to check if the base->current Mapping - in the uncertainty Region's FrameSet is a UnitMap or not (after - simplification). If it is, set the RegionFS attribute of the uncertainty - Region to zero (i.e. false). This will cause the FrameSet to be omitted - from the Dump. */ - map2 = astGetMapping( this->unc->frameset, AST__BASE, AST__CURRENT ); - smap = astSimplify( map2 ); - if( astIsAUnitMap( smap ) ) astSetRegionFS( this->unc, 0 ); - -/* Re-centre the uncertainty Region at the first position in the PointSet - associated with the Region structure (if any). */ - if( this->points ) { - ptr_reg = astGetPoints( this->points ); - astRegCentre( this->unc, NULL, ptr_reg, 0, AST__CURRENT ); - } - -/* Set a flag indicating that the uncertainty in the Region has changed. */ - changed = 1; - -/* Free resources */ - map2 = astAnnul( map2 ); - smap = astAnnul( smap ); - } - frm = astAnnul( frm ); - fs2 = astAnnul( fs2 ); - map = astAnnul( map ); - -/* Report error if conversion between Frames is not possible. */ - } else if( astOK ) { - astError( AST__BADIN, "astSetUnc(%s): Bad %d dimensional " - "uncertainty Frame (%s %s) supplied.", status, astGetClass(this), - astGetNaxes(unc), astGetDomain(unc), astGetTitle(unc) ); - astError( AST__NCPIN, "Cannot convert it to the Frame of the " - "new %s.", status, astGetClass( this ) ); - } - -/* Report an error if it is not of a usable class. */ - } else if( unc && astOK ){ - astError( AST__BADIN, "astSetUnc(%s): Bad uncertainty shape " - "(%s) supplied.", status, astGetClass( this ), astGetClass(unc) ); - astError( AST__NCPIN, "The uncertainty Region must be an instance of " - "a centro-symetric subclass of Region (e.g. Box, Circle, " - "Ellipse, etc)." , status); - } - -/* If the uncertainty in the Region has changed, indicate that any cached - information in the Region is now out of date. */ - if( changed ) astResetCache( this ); - -} - -static void ShowMesh( AstRegion *this, int format, const char *ttl, int *status ){ -/* -*++ -* Name: -c astShowMesh -f AST_SHOWMESH - -* Purpose: -* Display a mesh of points covering the surface of a Region. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c void astShowMesh( AstRegion *this, int format, const char *ttl ) -f CALL AST_SHOWMESH( THIS, FORMAT, TTL, STATUS ) - -* Class Membership: -* Region method. - -* Description: -c This function -f This routine -* writes a table to standard output containing the axis values at a -* mesh of points covering the surface of the supplied Region. Each row -* of output contains a tab-separated list of axis values, one for -* each axis in the Frame encapsulated by the Region. The number of -* points in the mesh is determined by the MeshSize attribute. -* -* The table is preceded by a given title string, and followed by a -* single line containing the word "ENDMESH". - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c format -f FORMAT = LOGICAL (Given) -* A boolean value indicating if the displayed axis values should -* be formatted according to the Format attribute associated with -* the Frame's axis. Otherwise, they are displayed as simple -* floating point values. -c ttl -f TTL = CHARACTER * ( * ) (Given) -* A title to display before displaying the first position. -f STATUS = INTEGER (Given and Returned) -f The global status. - -*-- -*/ - -/* Local Variables: */ - AstPointSet *ps; /* PointSet holding mesh */ - char *buffer = NULL; /* Buffer for line output text */ - char buf[ 40 ]; /* Buffer for floating poitn value */ - double **ptr; /* Pointers to the mesh data */ - int i; /* Axis index */ - int j; /* Position index */ - int nax; /* Number of axes */ - int nc; /* Number of characters in buffer */ - int np; /* Number of axis values per position */ - -/* Check the inherited status. */ - if( !astOK ) return; - -/* Get a PointSet holding the mesh */ - ps = astRegMesh( this ); - if( ps ) { - -/* Get the number of axis values per position, and the number of positions. */ - nax = astGetNcoord( ps ); - np = astGetNpoint( ps ); - -/* Get a pointer to the mesh data, and check it can be used. */ - ptr = astGetPoints( ps ); - if( ptr ) { - -/* Display the title. */ - if( ttl ) printf( "\n%s\n\n", ttl ); - -/* Loop round all positions. */ - for( j = 0; j < np; j++ ) { - -/* Reset the current buffer length to zero. */ - nc = 0; - -/* Loop round all axes */ - for( i = 0; i < nax; i++ ){ - -/* If the axis value is bad, append "<bad> in the end of the output buffer. */ - if( ptr[ i ][ j ] == AST__BAD ){ - buffer = astAppendString( buffer, &nc, "<bad>" ); - -/* Otherwise, if required, append the formatted value to the end of the - buffer. */ - } else if( format ){ - buffer = astAppendString( buffer, &nc, - astFormat( this, i, ptr[ i ][ j ] ) ); - -/* Otherwise, append the floating point value to the end of the buffer. */ - } else { - sprintf( buf, "%g", ptr[ i ][ j ] ); - buffer = astAppendString( buffer, &nc, buf ); - } -/* Add a separating tab to the end of the buffer. */ - buffer = astAppendString( buffer, &nc, "\t" ); - } - -/* Display the line buffer. */ - printf( "%s\n", buffer ); - } - } - -/* Print out a marker for th eend of the list. */ - printf( "ENDMESH\n\n" ); - -/* Release resources. */ - ps = astAnnul( ps ); - buffer = astFree( buffer ); - } -} - -static AstMapping *Simplify( AstMapping *this_mapping, int *status ) { -/* -* Name: -* Simplify - -* Purpose: -* Simplify the Mapping represented by a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstMapping *Simplify( AstMapping *this, int *status ) - -* Class Membership: -* Region method (over-rides the astSimplify method inherited -* from the Frame class). - -* Description: -* This function simplifies the encapsulated FrameSet and any -* uncertainty Region in the supplied Region. This is different to -* the Simplify method in the parent Frame class which always returns -* a UnitMap. - -* Parameters: -* this -* Pointer to the original Region. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A pointer to the simplified Region. A cloned pointer to the -* supplied Region will be returned if no simplication could be -* performed. - -* Notes: -* - This implementation just simplifies the encapsulated FrameSet -* and uncertainty Region. Sub-classes should usually provide their own -* implementation which invokes this implemetation, and then continues to -* check for further simplifications (such as fitting a new region to the -* current Frame). -* - A NULL pointer value will be returned if this function is -* invoked with the AST error status set, or if it should fail for -* any reason. -*/ - -/* Local Variables: */ - AstFrame *bfrm; /* Pointer to "this" baseFrame */ - AstFrameSet *fs; /* Pointer to encapsulated FrameSet */ - AstMapping *map; /* Base->current Mapping for "this" */ - AstMapping *result; /* Result pointer to return */ - AstPointSet *pset1; /* Base Frame centre position */ - AstPointSet *pset2; /* Current Frame centre position */ - AstRegion *new; /* Pointer to simplified Region */ - AstRegion *sunc; /* Simplified uncertainty Region */ - AstRegion *this; /* Pointer to original Region structure */ - AstRegion *unc; /* Original uncertainty Region */ - double **ptr1; /* Pointer to axis values in "pset1" */ - double *cen; /* Original centre of uncertainty Region */ - double *lbnd; /* Lower bounds of "this" bounding box */ - double *orig_cen; /* Original centre for uncertainty Region */ - double *s1_lbnd; /* Lower bounds of "unc" when centred at lbnd */ - double *s1_ubnd; /* Upper bounds of "unc" when centred at lbnd */ - double *s2_lbnd; /* Lower bounds of "unc" when centred at ubnd */ - double *s2_ubnd; /* Upper bounds of "unc" when centred at ubnd */ - double *ubnd; /* Upper bounds of "this" bounding box */ - double delta; /* Half width of test box */ - double w1; /* Width of "s1" bounding box */ - double w2; /* Width of "s2" bounding box */ - int ic; /* Axis index */ - int naxb; /* No. of base Frame axes in "this" */ - int nin; /* Number of base Frame axes in "this" */ - int nout; /* Number of current Frame axes in "this" */ - int ok; /* Can we use the simplified uncertainty? */ - int simpler; /* Has some simplication taken place? */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_mapping; - -/* Take a deep copy of the supplied Region. This is so that the returned - pointer will have a diferent value to the supplied pointer if any - simplication takes place. */ - new = astCopy( this ); - -/* Simplify the encapsulated FrameSet, and note if any simplification took - place. */ - fs = astSimplify( new->frameset ); - simpler = ( fs != new->frameset ); - -/* If so, annull the existing FrameSet and use the simpler FrameSet. */ - if( simpler ) { - (void) astAnnul( new->frameset ); - new->frameset = astClone( fs ); - } - fs = astAnnul( fs ); - -/* If the Region has default uncertainty, we simplify the uncertainty - Region simply by deleting it. It will be regenerated when needed, - using the simplified Region. */ - if( new->defunc ) new->defunc = astAnnul( new->defunc ); - -/* If the Region's uncertainty was supplied explicitly, try simplifying - the unncertainty Region. */ - if( astTestUnc( new ) ){ - -/* Obtain the Region's uncertainty. */ - unc = astGetUncFrm( new, AST__BASE ); - -/* Get the base->current Mapping from "this". */ - map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT ); - -/* If it has different numbers of inputs and outputs (e.g. a PermMap used - to take a slice through a Region), we need to ensure that the - uncertainty Region is centred on the slice. */ - nin = astGetNin( map ); - nout = astGetNout( map ); - if( nin != nout ) { - -/* Get the current centre of the uncertainty Region in its current Frame - (the same as the base Frame of "this"). */ - cen = astRegCentre( unc, NULL, NULL, 0, AST__CURRENT ); - -/* Store it in a PointSet so it can be transformed. */ - pset1 = astPointSet( 1, nin, "", status ); - ptr1 = astGetPoints( pset1 ); - if( astOK ) for( ic = 0; ic < nin; ic++ ) ptr1[ ic ][ 0 ] = cen[ ic ]; - -/* Transform into the curent Frame of "this", and then back into the base - Frame. */ - pset2 = astTransform( map, pset1, 1, NULL ); - (void) astTransform( map, pset2, 0, pset1 ); - -/* Re-centre the uncertainty Region at this position. */ - astRegCentre( unc, NULL, ptr1, 0, AST__CURRENT ); - -/* Free resources. */ - cen = astFree( cen ); - pset1 = astAnnul( pset1 ); - pset2 = astAnnul( pset2 ); - } - -/* Free resources. */ - map = astAnnul( map ); - -/* Try simplifying the uncertainty. Only proceed if the uncertainty can - be simplified. */ - sunc = astSimplify( unc ); - if( sunc != unc ) { - -/* If the uncertainty can be simplified it means that the base->current - Mapping in the uncertainty Region is sufficiently linear to allow the - uncertainty shape to retain its form when transformed from the base to - the current Frane. But this has only been tested at the current centre - position in the uncertainty Region. The uncertainty Region should - describe the whole of "this" Region, and so we need to check that the - simplified uncertainty does not change as we move it around within "this" - Region. To do this, we re-centre the uncertainty region at opposite - corners of a large test box, and then we find the bounding box of the - re-centred uncertainty Region. If this uncertainty bounding box changes - from corner to corner of the test box, then we do not simplify the - uncertainty Region. If "this" is bounded, we use the bounding box of - "this" as the test box. Otherwise we use a box 100 times the size of the - uncertainty Region. */ - -/* Note the original base Frame centre of the simplified uncertainty Region. */ - orig_cen = astRegCentre( sunc, NULL, NULL, 0, AST__BASE ); - -/* Allocate memory to hold the bounds of the test box. */ - naxb = astGetNin( this->frameset ); - lbnd = astMalloc( sizeof( double )*(size_t)naxb ); - ubnd = astMalloc( sizeof( double )*(size_t)naxb ); - -/* If possible, get the base Frame bounding box of "this" and use it as - the test box. */ - if( astGetBounded( this ) ) { - astRegBaseBox( this, lbnd, ubnd ); - -/* Otherwise, store the bounds of a box which is 100 times the size of - the uncertainty region, centred on the current centre of the uncertainty - region (we know all uncertainty regions are bounded). */ - } else { - astGetRegionBounds( sunc, lbnd, ubnd ); - for( ic = 0; ic < naxb; ic++ ) { - delta = 0.5*fabs( ubnd[ ic ] - lbnd[ ic ] ); - lbnd[ ic ] = orig_cen[ ic ] - delta; - ubnd[ ic ] = orig_cen[ ic ] + delta; - } - } - -/* Re-centre it at the lower bounds of the test box. This is in the base Frame - of "this" which is the same as the current Frame of "sunc". */ - astRegCentre( sunc, lbnd, NULL, 0, AST__CURRENT ); - -/* Get the bounding box of the re-centred uncertainty Region, within its - current Frame, which is the same as the base Frame of "this". */ - s1_lbnd = astMalloc( sizeof( double )*(size_t)naxb ); - s1_ubnd = astMalloc( sizeof( double )*(size_t)naxb ); - astGetRegionBounds( sunc, s1_lbnd, s1_ubnd ); - -/* Now re-centre the uncertainty Region at the upper bounds of the test - box. */ - astRegCentre( sunc, ubnd, NULL, 0, AST__CURRENT ); - -/* Get the bounding box of the re-centred uncertainty Region. */ - s2_lbnd = astMalloc( sizeof( double )*(size_t)naxb ); - s2_ubnd = astMalloc( sizeof( double )*(size_t)naxb ); - astGetRegionBounds( sunc, s2_lbnd, s2_ubnd ); - -/* Get a pointer to the base Frame of "this". */ - bfrm = astGetFrame( this->frameset, AST__BASE ); - -/* The "ok" flag is initialised to indicate that the simplified uncertainty - Region should not be used. */ - ok = 0; - -/* Check pointers can be referenced safely */ - if( astOK ) { - -/* Now indicate that the simplified uncertainty Region should be used. */ - ok = 1; - -/* Loop round all axes of the base Frame of "this". */ - for( ic = 0; ic < naxb; ic++ ) { - -/* Get the width of the two bounding boxes on this axis. */ - w1 = s1_ubnd[ ic ] - s1_lbnd[ ic ]; - w2 = s2_ubnd[ ic ] - s2_lbnd[ ic ]; - -/* If these differ by more than 0.1% then we determine that the simplified - uncertainty Region varies in size across the bounding box of "this", and - so we do not use the simplified uncertainty Region. The figure of 0.1% - is arbitrary. */ - if( fabs( w1 - w2 ) > 0.005*( fabs( w1 ) + fabs( w2 ) ) ) { - ok = 0; - break; - } - } - } - -/* Reinstate the original base Frame centre of the simplified uncertainty Region. */ - astRegCentre( sunc, orig_cen, NULL, 0, AST__BASE ); - -/* Free resources. */ - orig_cen = astFree( orig_cen ); - lbnd = astFree( lbnd ); - ubnd = astFree( ubnd ); - s1_lbnd = astFree( s1_lbnd ); - s1_ubnd = astFree( s1_ubnd ); - s2_lbnd = astFree( s2_lbnd ); - s2_ubnd = astFree( s2_ubnd ); - bfrm = astAnnul( bfrm ); - -/* If we can use the simplified uncertainty Region, indicate that we have - performed some simplification, and store the new uncertainty Region. */ - if( ok ) { - simpler = 1; - astSetUnc( new, sunc ); - } - } - -/* Free resources */ - unc = astAnnul( unc ); - sunc = astAnnul( sunc ); - } - -/* If any simplification could be performed, return the new Region. - Otherwise, return a clone of the supplied pointer. */ - if( simpler ){ - result = (AstMapping *) new; - } else { - new = astAnnul( new ); - result = astClone( this ); - } - -/* If an error occurred, annul the returned pointer. */ - if ( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - -static int SubFrame( AstFrame *this_frame, AstFrame *template, - int result_naxes, - const int *target_axes, const int *template_axes, - AstMapping **map, AstFrame **result, int *status ) { -/* -* Name: -* SubFrame - -* Purpose: -* Select axes from a Region and convert to the new coordinate system. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int SubFrame( AstFrame *target, AstFrame *template, int result_naxes, -* const int *target_axes, const int *template_axes, -* AstMapping **map, AstFrame **result, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astSubFrame -* method inherited from the Frame class). - -* Description: -* This function selects a requested sub-set (or super-set) of the -* axes from the current Frame of a "target" Region and creates a -* new Frame with copies of the selected axes assembled in the -* requested order. It then optionally overlays the attributes of a -* "template" Frame on to the result. It returns both the resulting -* Frame and a Mapping that describes how to convert between the -* coordinate systems described by the current Frame of the target -* Region and the result Frame. If necessary, this Mapping takes -* account of any differences in the Frames' attributes due to the -* influence of the template. - -* Parameters: -* target -* Pointer to the target Region, from whose current Frame the -* axes are to be selected. -* template -* Pointer to the template Frame, from which new attributes for -* the result Frame are to be obtained. Optionally, this may be -* NULL, in which case no overlaying of template attributes will -* be performed. -* result_naxes -* Number of axes to be selected from the target Region. This -* number may be greater than or less than the number of axes in -* the Region's current Frame (or equal). -* target_axes -* Pointer to an array of int with result_naxes elements, giving -* a list of the (zero-based) axis indices of the axes to be -* selected from the current Frame of the target Region. The -* order in which these are given determines the order in which -* the axes appear in the result Frame. If any of the values in -* this array is set to -1, the corresponding result axis will -* not be derived from the target Region, but will be assigned -* default attributes instead. -* template_axes -* Pointer to an array of int with result_naxes elements. This -* should contain a list of the template axes (given as -* zero-based axis indices) with which the axes of the result -* Frame are to be associated. This array determines which axes -* are used when overlaying axis-dependent attributes of the -* template on to the result. If any element of this array is -* set to -1, the corresponding result axis will not receive any -* template attributes. -* -* If the template argument is given as NULL, this array is not -* used and a NULL pointer may also be supplied here. -* map -* Address of a location to receive a pointer to the returned -* Mapping. The forward transformation of this Mapping will -* describe how to convert coordinates from the coordinate -* system described by the current Frame of the target Region -* to that described by the result Frame. The inverse -* transformation will convert in the opposite direction. -* result -* Address of a location to receive a pointer to the result Frame. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* A non-zero value is returned if coordinate conversion is -* possible between the current Frame of the target Region and -* the result Frame. Otherwise zero is returned and *map and -* *result are returned as NULL (but this will not in itself result -* in an error condition). In general, coordinate conversion should -* always be possible if no template Frame is supplied but may not -* always be possible otherwise. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to Region's current Frame */ - int match; /* Result to be returned */ - -/* Initialise. */ - *map = NULL; - *result = NULL; - match = 0; - -/* Check the global error status. */ - if ( !astOK ) return match; - -/* Invoke the parent astSubFrame method on the Frame represented by the - region. */ - fr = astGetFrame( ((AstRegion *) this_frame)->frameset, AST__CURRENT ); - match = astSubFrame( fr, template, result_naxes, target_axes, template_axes, - map, result ); - fr = astAnnul( fr ); - -/* Return the result. */ - return match; -} - -static AstSystemType SystemCode( AstFrame *this_frame, const char *system, int *status ) { -/* -* Name: -* SystemCode - -* Purpose: -* Convert a string into a coordinate system type code. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* AstSystemType SystemCode( AstFrame *this, const char *system, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astSystemCode -* method inherited from the Frame class). - -* Description: -* This function converts a string used for the external description of -* a coordinate system into a Frame coordinate system type code (System -* attribute value). It is the inverse of the astSystemString function. - -* Parameters: -* this -* Pointer to the Frame. -* system -* Pointer to a constant null-terminated string containing the -* external description of the coordinate system. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The System type code. - -* Notes: -* - A value of AST__BADSYSTEM is returned if the coordinate system -* description was not recognised. This does not produce an error. -* - A value of AST__BADSYSTEM is also returned if this function -* is invoked with the global error status set or if it should fail -* for any reason. -*/ - -/* Local Variables: */ - AstSystemType result; /* Result value to return */ - AstFrame *fr; /* Pointer to FrameSet's current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Initialise. */ - result = AST__BADSYSTEM; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astSystemCode method for this Frame. Annul the Frame pointer afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astSystemCode( fr, system ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BADSYSTEM; - -/* Return the result. */ - return result; -} - -static const char *SystemString( AstFrame *this_frame, AstSystemType system, int *status ) { -/* -* Name: -* SystemString - -* Purpose: -* Convert a coordinate system type code into a string. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* const char *SystemString( AstFrame *this, AstSystemType system, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astSystemString -* method inherited from the Frame class). - -* Description: -* This function converts a Frame coordinate system type code -* (System attribute value) into a string suitable for use as an -* external representation of the coordinate system type. - -* Parameters: -* this -* Pointer to the Frame. -* system -* The coordinate system type code. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* Pointer to a constant null-terminated string containing the -* textual equivalent of the type code supplied. - -* Notes: -* - A NULL pointer value is returned if the coordinate system -* code was not recognised. This does not produce an error. -* - A NULL pointer value is also returned if this function is -* invoked with the global error status set or if it should fail -* for any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to FrameSet's current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - const char *result; /* Pointer value to return */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astSystemString method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astSystemString( fr, system ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = NULL; - -/* Return the result pointer. */ - return result; - -} - -static int RegTrace( AstRegion *this, int n, double *dist, double **ptr, int *status ){ -/* -*+ -* Name: -* astRegTrace - -* Purpose: -* Return requested positions on the boundary of a 2D Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* int astRegTrace( AstRegion *this, int n, double *dist, double **ptr ); - -* Class Membership: -* Region virtual function - -* Description: -* This function returns positions on the boundary of the supplied -* Region, if possible. The required positions are indicated by a -* supplied list of scalar parameter values in the range zero to one. -* Zero corresponds to some arbitrary starting point on the boundary, -* and one corresponds to the end (which for a closed region will be -* the same place as the start). - -* Parameters: -* this -* Pointer to the Region. -* n -* The number of positions to return. If this is zero, the function -* returns without action (but the returned function value still -* indicates if the method is supported or not). -* dist -* Pointer to an array of "n" scalar parameter values in the range -* 0 to 1.0. -* ptr -* A pointer to an array of pointers. The number of elements in -* this array should equal tthe number of axes in the Frame spanned -* by the Region. Each element of the array should be a pointer to -* an array of "n" doubles, in which to return the "n" values for -* the corresponding axis. The contents of the arrays are unchanged -* if the supplied Region belongs to a class that does not -* implement this method. - -* Returned Value: -* Non-zero if the astRegTrace method is implemented by the class -* of Region supplied, and zero if not. - -*- -*/ - -/* Concrete sub-classes of Region must over-ride this method. */ - return 0; -} - -static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) { -/* -* Name: -* TestAttrib - -* Purpose: -* Test if a specified attribute value is set for a Region. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int TestAttrib( AstObject *this, const char *attrib, int *status ) - -* Class Membership: -* Region member function (over-rides the astTestAttrib protected -* method inherited from the Frame class). - -* Description: -* This function returns a boolean result (0 or 1) to indicate whether -* a value has been set for one of a Region's attributes. - -* Parameters: -* this -* Pointer to the Region. -* attrib -* Pointer to a null terminated string specifying the attribute -* name. This should be in lower case with no surrounding white -* space. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* One if a value has been set, otherwise zero. - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global status set, or if it should fail for any reason. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to the Region structure */ - int result; /* Result value to return */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* Check the attribute name and test the appropriate attribute. */ - -/* We first handle attributes that apply to the Region as a whole - (rather than to the encapsulated FrameSet). */ - -/* Negated. */ -/* -------- */ - if ( !strcmp( attrib, "negated" ) ) { - result = astTestNegated( this ); - -/* Closed. */ -/* ------- */ - } else if ( !strcmp( attrib, "closed" ) ) { - result = astTestClosed( this ); - -/* FillFactor */ -/* ---------- */ - } else if ( !strcmp( attrib, "fillfactor" ) ) { - result = astTestFillFactor( this ); - -/* MeshSize */ -/* -------- */ - } else if ( !strcmp( attrib, "meshsize" ) ) { - result = astTestMeshSize( this ); - -/* Adaptive */ -/* -------- */ - } else if ( !strcmp( attrib, "adaptive" ) ) { - result = astTestAdaptive( this ); - -/* Now do attributes inherited from parent classes. This is so that the - attribute test will not be passed on to the encpasulated FrameSet below. */ - -/* ID. */ -/* --- */ - } else if ( !strcmp( attrib, "id" ) ) { - result = astTestID( this ); - -/* Ident. */ -/* ------ */ - } else if ( !strcmp( attrib, "ident" ) ) { - result = astTestIdent( this ); - -/* Invert. */ -/* ------- */ - } else if ( !strcmp( attrib, "invert" ) ) { - result = astTestInvert( this ); - -/* Report. */ -/* ------- */ - } else if ( !strcmp( attrib, "report" ) ) { - result = astTestReport( this ); - -/* If the name is not recognised, test if it matches any of the - read-only attributes of this class. If it does, then return - zero. */ - } else if ( !strcmp( attrib, "class" ) || - !strcmp( attrib, "nin" ) || - !strcmp( attrib, "nobject" ) || - !strcmp( attrib, "bounded" ) || - !strcmp( attrib, "nout" ) || - !strcmp( attrib, "refcount" ) || - !strcmp( attrib, "tranforward" ) || - !strcmp( attrib, "traninverse" ) ) { - result = 0; - -/* Pass unrecognised attributes on to the Region's encapsulated FrameSet for - further interpretation. Do not pass on FrameSet attributes since we - pretend to the outside world that the encapsulated FrameSet is actually a - Frame. */ - } else if ( strcmp( attrib, "base" ) && - strcmp( attrib, "current" ) && - strcmp( attrib, "nframe" ) ) { - result = astTestAttrib( this->frameset, attrib ); - } - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result, */ - return result; -} - -double *astRegTranPoint_( AstRegion *this, double *in, int np, int forward, int *status ){ -/* -*+ -* Name: -* astRegTranPoint - -* Purpose: -* Transform points between the base and current Frames in a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* double *astRegTranPoint( AstRegion *this, double *in, int np, int forward ) - -* Class Membership: -* Region member function - -* Description: -* This function transforms one or more points between the base and -* current Frames of the FrameSet encapsulated by the supplied Region. - -* Parameters: -* this -* The Region pointer. -* in -* Pointer to a 1-d array holding the axis values to be transformed. -* If "forward" is non-zero, the number of axis values supplied for -* each position should equal the number of axes in the base Frame -* of the FrameSet encapsulated by "this". If "forward" is zero, the -* number of axis values supplied for each position should equal the -* number of axes in the current Frame of the FrameSet encapsulated by -* "this". All the axis values for a position should be in adjacent -* elements of the array. -* np -* The number of points supplied in "in". -* forward -* If non-zero, the supplied points are assumed to refer to the base -* Frame of the encapsulated FrameSet, and they are transformed to the -* current Frame. If zero, the supplied points are assumed to refer to -* the current Frame of the encapsulated FrameSet, and they are -* transformed to the base Frame. - -* Returned Value: -* Pointer to a new dynamically allocated array holding the -* transformed axis values. If "forward" is non-zero, the number of axis -* values for each position will be equal the number of axes in the -* current Frame of the FrameSet encapsulated by "this". If "forward" is -* zero, the number of axis values for each position will be equal to the -* number of axes in the base Frame of the FrameSet encapsulated by "this". -* All the axis values for a position will be in adjacent elements of the -* array. The array should be freed using astFree when no longer needed. - -* Notes: -* - A NULL pointer is returned if an error has already occurred, or if -* this function should fail for any reason. - -*- -*/ - -/* Local Variables: */ - AstMapping *map; - AstPointSet *pset_in; - AstPointSet *pset_out; - double **ptr_in; - double **ptr_out; - double *p; - double *result; - int ic; - int ip; - int naxin; - int naxout; - -/* Initialise */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Get a pointer to the required Mapping. */ - if( forward ) { - map = astGetMapping( this->frameset, AST__BASE, AST__CURRENT ); - } else { - map = astGetMapping( this->frameset, AST__CURRENT, AST__BASE ); - } - -/* Get the number of axis values per input and per output point. */ - naxin = astGetNin( map ); - naxout = astGetNout( map ); - -/* Create a pointSet holding the supplied axis values. */ - pset_in = astPointSet( np, naxin, "", status ); - -/* Get pointers to the memory used to store axis values within this - PointSet. */ - ptr_in = astGetPoints( pset_in ); - -/* Allocate the output array. */ - result = astMalloc( sizeof( double )*(size_t)( naxout*np ) ); - -/* Check the pointers can be used. */ - if( astOK ) { - -/* Store the supplied axis values in the PointSet memory. */ - p = in; - for( ip = 0; ip < np; ip++ ) { - for( ic = 0; ic < naxin; ic++ ) ptr_in[ ic ][ ip ] = *(p++); - } - -/* Transform the PointSet. */ - pset_out = astTransform( map, pset_in, 1, NULL ); - -/* Get a pointer to the memory in the transformed PointSet. */ - ptr_out = astGetPoints( pset_out ); - - if( pset_out && astStatus == AST__INTER ) { - p = in; - for( ip = 0; ip < np; ip++ ) { - for( ic = 0; ic < naxin; ic++ ) printf("%.*g\n", AST__DBL_DIG, *(p++) ); - } - } - - if( astOK ) { - -/* Store the resulting axis values in the output array. */ - p = result; - for( ip = 0; ip < np; ip++ ) { - for( ic = 0; ic < naxout; ic++ ) *(p++) = ptr_out[ ic ][ ip ]; - } - } - -/* Free resources. */ - pset_out = astAnnul( pset_out ); - } - pset_in = astAnnul( pset_in ); - map = astAnnul( map ); - -/* Return NULL if anything went wrong. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result.*/ - return result; -} - -static AstPointSet *RegTransform( AstRegion *this, AstPointSet *in, - int forward, AstPointSet *out, AstFrame **frm, int *status ) { -/* -*+ -* Name: -* astRegTransform - -* Purpose: -* Transform a set of points using the encapsulated FrameSet. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstPointSet *astRegTransform( AstRegion *this, AstPointSet *in, -* int forward, AstPointSet *out, -* AstFrameSet **frm ) - -* Class Membership: -* Region virtual function - -* Description: -* This function takes a Region and a set of points encapsulated -* in a PointSet, and applies either the forward or inverse -* coordinate transformation represented by the encapsulated FrameSet. -* It also returned a pointer to either the current or base Frame in -* the FrameSet. - -* Parameters: -* this -* Pointer to the Region. -* in -* Pointer to the PointSet holding the input coordinate data. If -* NULL then the "points" PointSet within the supplied Region -* ("this") is used. -* forward -* A non-zero value indicates that the forward coordinate transformation -* (from base to current) should be applied, while a zero value requests -* the inverse transformation (from current to base). -* out -* Pointer to a PointSet which will hold the transformed (output) -* coordinate values. A NULL value may also be given, in which case a -* new PointSet will be created by this function. -* frm -* Location at which to return a pointer to a Frame. If "forward" -* is non-zero, the current Frame in the encapsulated FrameSet will -* be returned. Otherwise, the base Frame is returned. The returned -* pointer should be annulled when no longer needed. May be NULL if -* no pointer is needed. - -* Returned Value: -* Pointer to the output (possibly new) PointSet. If "out" is NULL, -* the returned pointer will be a clone of "in" if the Mapping is a -* UnitMap. If "out" is not NULL, then the supplied "out" PointSet will -* be used and returned. - -* Notes: -* - An error will result if the Region supplied does not define -* the requested coordinate transformation (either forward or -* inverse). -* - The number of coordinate values per point in the input -* PointSet must match the number of input coordinates for the -* Region being applied (or number of output coordinates if the -* inverse transformation is requested). This will be equal to the -* number of axes in the Region's base Frame (or the current -* Frame for the inverse transformation). -* - If an output PointSet is supplied, it must have space for -* sufficient number of points and coordinate values per point to -* accommodate the result (e.g. the number of Region output -* coordinates, or number of input coordinates if the inverse -* transformation is requested). Any excess space will be ignored. -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstMapping *smap; /* Pointer to simplified Mapping */ - AstPointSet *result; /* Pointer value to return */ - -/* Initialise */ - if( frm ) *frm = NULL; - -/* Check the global error status. */ - if ( !astOK ) return NULL; - -/* If no input PointSet was provided, use the PointSet in the Region. */ - if( !in ) { - if( this->points ) { - in = this->points; - } else { - astError( AST__INTER, "astRegTransform(%s): No PointSet supplied " - "and the supplied %s has no PointSet (internal AST " - "programming error)", status, astGetClass( this ),astGetClass( this ) ); - } - } - -/* Get the simplified Mapping from base to current Frame. */ - smap = astRegMapping( this ); - -/* If it is a UnitMap, return a clone of the input PointSet unless an - explicit output PointSet has been supplied. */ - if( astIsAUnitMap( smap ) && !out ) { - result = astClone( in ); - -/* Otherwise use the Mapping to transform the supplied positions. */ - } else { - result = astTransform( smap, in, forward, out ); - } - -/* Return a pointer to the appropriate Frame. */ - if( frm ) *frm = astGetFrame( this->frameset, forward ? AST__CURRENT : AST__BASE ); - -/* Release resources. */ - smap = astAnnul( smap ); - -/* Return a pointer to the output PointSet. */ - return result; -} - -static int Unformat( AstFrame *this_frame, int axis, const char *string, - double *value, int *status ) { -/* -* Name: -* Unformat - -* Purpose: -* Read a formatted coordinate value for a Region axis. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int Unformat( AstFrame *this, int axis, const char *string, -* double *value, int *status ) - -* Class Membership: -* Region member function (over-rides the public astUnformat -* method inherited from the Frame class). - -* Description: -* This function reads a formatted coordinate value for a Region -* axis (supplied as a string) and returns the equivalent numerical -* value as a double. It also returns the number of characters read -* from the string. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The number of the Region axis for which the coordinate -* value is to be read (axis numbering starts at zero for the -* first axis). -* string -* Pointer to a constant null-terminated string containing the -* formatted coordinate value. -* value -* Pointer to a double in which the coordinate value read will be -* returned. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The number of characters read from the string to obtain the -* coordinate value. - -* Notes: -* - Any white space at the beginning of the string will be -* skipped, as also will any trailing white space following the -* coordinate value read. The function's return value will reflect -* this. -* - A function value of zero (and no coordinate value) will be -* returned, without error, if the string supplied does not contain -* a suitably formatted value. -* - The string "<bad>" is recognised as a special case and will -* generate the value AST__BAD, without error. The test for this -* string is case-insensitive and permits embedded white space. -* - A function result of zero will be returned and no coordinate -* value will be returned via the "value" pointer if this function -* is invoked with the global error status set, or if it should -* fail for any reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - double coord; /* Coordinate value read */ - int nc; /* Number of characters read */ - -/* Initialise. */ - nc = 0; - -/* Check the global error status. */ - if ( !astOK ) return nc; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Validate the axis index. */ - (void) astValidateAxis( this, axis, 1, "astUnformat" ); - -/* Obtain a pointer to the Region's current Frame and invoke the - astUnformat method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - nc = astUnformat( fr, axis, string, &coord ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the number of characters read. */ - if ( !astOK ) { - nc = 0; - -/* Otherwise, if characters were read, return the coordinate value. */ - } else if ( nc ) { - *value = coord; - } - -/* Return the number of characters read. */ - return nc; -} - -static int ValidateAxis( AstFrame *this_frame, int axis, int fwd, - const char *method, int *status ) { -/* -* Name: -* ValidateAxis - -* Purpose: -* Validate and permute a Region's axis index. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int ValidateAxis( AstFrame *this, int axis, int fwd, const char *method, -* int *status ) - -* Class Membership: -* Region member function (over-rides the protected -* astValidateAxis method inherited from the Frame class). - -* Description: -* This function checks the validity of an index (zero-based) which -* is to be used to address one of the coordinate axes of the -* current Frame in a Region. If the index is valid, it is -* permuted using the axis permutation array associated with the -* Region's current Frame and the (zero-based) permuted axis -* index is returned. This gives the index the axis had when the -* Frame was first created. If the axis index supplied is not -* valid, an error is reported and the global error status is set. - -* Parameters: -* this -* Pointer to the Region. -* axis -* The axis index (zero-based) to be checked. To be valid, it -* must lie between zero and (naxes-1) inclusive, where "naxes" -* is the number of coordinate axes associated with the -* Region's current Frame. -* fwd -* If non-zero, the suppplied axis index is assumed to be an -* "external" axis index, and the corresponding "internal" axis index -* is returned as the function value. Otherwise, the suppplied axis -* index is assumed to be an "internal" axis index, and the -* corresponding "external" axis index is returned as the function -* value. -* method -* Pointer to a constant null-terminated character string -* containing the name of the method that invoked this function -* to validate an axis index. This method name is used solely -* for constructing error messages. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The permuted axis index - either "internal" or "external" as -* specified by "fwd". - -* Notes: -* - A value of zero will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - int naxes; /* Number of Region axes */ - int result; /* Permuted axis index */ - -/* Initialise. */ - result = 0; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_frame; - -/* Determine the number of Region axes. */ - naxes = astGetNaxes( this ); - if ( astOK ) { - -/* If the Region has no axes, report an error (convert to 1-based - axis numbering for the benefit of the public interface). */ - if ( naxes == 0 ) { - astError( AST__AXIIN, "%s(%s): Invalid attempt to use an axis index " - "(%d) for a %s which has no axes.", status, method, - astGetClass( this ), axis + 1, astGetClass( this ) ); - -/* Otherwise, check the axis index for validity and report an error if - it is not valid (again, convert to 1-based axis numbering). */ - } else if ( ( axis < 0 ) || ( axis >= naxes ) ) { - astError( AST__AXIIN, "%s(%s): Axis index (%d) invalid - it should " - "be in the range 1 to %d.", status, method, astGetClass( this ), - axis + 1, naxes ); - -/* If the axis index was valid, obtain a pointer to the Region's - current Frame and invoke this Frame's astValidateAxis method to - obtain the permuted axis index. Annul the Frame pointer - afterwards. */ - } else { - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astValidateAxis( fr, axis, fwd, "astValidateAxis" ); - fr = astAnnul( fr ); - } - } - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = 0; - -/* Return the result. */ - return result; -} - -static void ValidateAxisSelection( AstFrame *this_frame, int naxes, - const int *axes, const char *method, int *status ) { -/* -* Name: -* ValidateAxisSelection - -* Purpose: -* Check that a set of axes selected from a Frame is valid. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* void ValidateAxisSelection( AstFrame *this, int naxes, -* const int *axes, const char *method, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astValidateAxisSelection -* method inherited from the Frame class). - -* Description: -* This function checks the validity of an array of (zero-based) -* axis indices that specify a set of axes to be selected from a -* Frame. To be valid, no axis should be selected more than -* once. In assessing this, any axis indices that do not refer to -* valid Frame axes (e.g. are set to -1) are ignored. -* -* If the axis selection is valid, this function returns without further -* action. Otherwise, an error is reported and the global error status is -* set. - -* Parameters: -* this -* Pointer to the Frame. -* naxes -* The number of axes to be selected (may be zero). -* axes -* Pointer to an array of int with naxes elements that contains the -* (zero based) axis indices to be checked. -* method -* Pointer to a constant null-terminated character string -* containing the name of the method that invoked this function -* to validate an axis selection. This method name is used -* solely for constructing error messages. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke this - Frame's astValidateAxisSelection method. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - astValidateAxisSelection( fr, naxes, axes, method ); - fr = astAnnul( fr ); - -} - -static int ValidateSystem( AstFrame *this_frame, AstSystemType system, const char *method, int *status ) { -/* -* Name: -* ValidateSystem - -* Purpose: -* Validate a value for a Frame's System attribute. - -* Type: -* Private function. - -* Synopsis: -* #include "region.h" -* int ValidateSystem( AstFrame *this, AstSystemType system, -* const char *method, int *status ) - -* Class Membership: -* Region member function (over-rides the protected astValidateSystem -* method inherited from the Frame class). - -* Description: -* This function checks the validity of the supplied system value. -* If the value is valid, it is returned unchanged. Otherwise, an -* error is reported and a value of AST__BADSYSTEM is returned. - -* Parameters: -* this -* Pointer to the Frame. -* system -* The system value to be checked. -* method -* Pointer to a constant null-terminated character string -* containing the name of the method that invoked this function -* to validate an axis index. This method name is used solely -* for constructing error messages. -* status -* Pointer to the inherited status variable. - -* Returned Value: -* The validated system value. - -* Notes: -* - A value of AST_BADSYSTEM will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstSystemType result; /* Validated system value */ - AstFrame *fr; /* Pointer to FrameSet's current Frame */ - AstRegion *this; /* Pointer to the Region structure */ - -/* Initialise. */ - result = AST__BADSYSTEM; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Obtain a pointer to the FrameSet structure. */ - this = (AstRegion *) this_frame; - -/* Obtain a pointer to the Region's encapsulated Frame and invoke the - astValidateSystem method for this Frame. Annul the Frame pointer - afterwards. */ - fr = astGetFrame( this->frameset, AST__CURRENT ); - result = astValidateSystem( this, system, method ); - fr = astAnnul( fr ); - -/* If an error occurred, clear the result value. */ - if ( !astOK ) result = AST__BADSYSTEM; - -/* Return the result. */ - return result; -} - -/* Region Attributes. */ -/* -------------------- */ - -/* -*att++ -* Name: -* Adaptive - -* Purpose: -* Should the area adapt to changes in the coordinate system? - -* Type: -* Public attribute. - -* Synopsis: -* Integer (boolean). - -* Description: -* The coordinate system represented by a Region may be changed by -* assigning new values to attributes such as System, Unit, etc. -* For instance, a Region representing an area on the sky in ICRS -* coordinates may have its System attribute changed so that it -* represents (say) Galactic coordinates instead of ICRS. This -* attribute controls what happens when the coordinate system -* represented by a Region is changed in this way. -* -* If Adaptive is non-zero (the default), then area represented by the -* Region adapts to the new coordinate system. That is, the numerical -* values which define the area represented by the Region are changed -* by mapping them from the old coordinate system into the new coordinate -* system. Thus the Region continues to represent the same physical -* area. -* -* If Adaptive is zero, then area represented by the Region does not adapt -* to the new coordinate system. That is, the numerical values which -* define the area represented by the Region are left unchanged. Thus -* the physical area represented by the Region will usually change. -* -* As an example, consider a Region describe a range of wavelength from -* 2000 Angstrom to 4000 Angstrom. If the Unit attribute for the Region -* is changed from Angstrom to "nm" (nanometre), what happens depends -* on the setting of Adaptive. If Adaptive is non-zero, the Mapping -* from the old to the new coordinate system is found. In this case it -* is a simple scaling by a factor of 0.1 (since 1 Angstrom is 0.1 nm). -* This Mapping is then used to modify the numerical values within the -* Region, changing 2000 to 200 and 4000 to 400. Thus the modified -* region represents 200 nm to 400 nm, the same physical space as -* the original 2000 Angstrom to 4000 Angstrom. However, if Adaptive -* had been zero, then the numerical values would not have been changed, -* resulting in the final Region representing 2000 nm to 4000 nm. -* -* Setting Adaptive to zero can be necessary if you want correct -* inaccurate attribute settings in an existing Region. For instance, -* when creating a Region you may not know what Epoch value to use, so -* you would leave Epoch unset resulting in some default value being used. -* If at some later point in the application, the correct Epoch value -* is determined, you could assign the correct value to the Epoch -* attribute. However, you would first need to set Adaptive temporarily -* to zero, because otherwise the area represented by the Region would -* be Mapped from the spurious default Epoch to the new correct Epoch, -* which is not what is required. - -* Applicability: -* Region -* All Regions have this attribute. -*att-- -*/ - -/* This is a boolean value (0 or 1) with a value of -INT_MAX when - undefined but yielding a default of 1. */ -astMAKE_CLEAR(Region,Adaptive,adaptive,-INT_MAX) -astMAKE_GET(Region,Adaptive,int,1,( ( this->adaptive == -INT_MAX ) ? - 1 : this->adaptive )) -astMAKE_SET(Region,Adaptive,int,adaptive,( value != 0 )) -astMAKE_TEST(Region,Adaptive,( this->adaptive != -INT_MAX )) - -/* -*att++ -* Name: -* Negated - -* Purpose: -* Region negation flag. - -* Type: -* Public attribute. - -* Synopsis: -* Integer (boolean). - -* Description: -* This attribute controls whether a Region represents the "inside" or -* the "outside" of the area which was supplied when the Region was -* created. If the attribute value is zero (the default), the Region -* represents the inside of the original area. However, if it is non-zero, -* it represents the outside of the original area. The value of this -* attribute may be toggled using the -c astNegate function. -f AST_NEGATE routine. - -* Note, whether the boundary is considered to be inside the Region or -* not is controlled by the Closed attribute. Changing the value of -* the Negated attribute does not change the value of the Closed attribute. -* Thus, if Region is closed, then the boundary of the Region will be -* inside the Region, whatever the setting of the Negated attribute. - -* Applicability: -* Region -* All Regions have this attribute. -*att-- -*/ - -/* This is a boolean value (0 or 1) with a value of -INT_MAX when - undefined but yielding a default of zero. */ -astMAKE_CLEAR(Region,Negated,negated,(astResetCache(this),-INT_MAX)) -astMAKE_GET(Region,Negated,int,0,( ( this->negated == -INT_MAX ) ? - 0 : this->negated )) -astMAKE_SET(Region,Negated,int,negated,(astResetCache(this),( value != 0 ))) -astMAKE_TEST(Region,Negated,( this->negated != -INT_MAX )) - -/* -*att++ -* Name: -* Bounded - -* Purpose: -* Is the Region bounded? - -* Type: -* Public attribute. - -* Synopsis: -* Integer (boolean), read-only. - -* Description: -* This is a read-only attribute indicating if the Region is bounded. -* A Region is bounded if it is contained entirely within some -* finite-size bounding box. - -* Applicability: -* Region -* All Regions have this attribute. -*att-- -*/ - -/* -*att+ -* Name: -* RegionFS - -* Purpose: -* Should Region FrameSet be dumped? - -* Type: -* Protected attribute. - -* Synopsis: -* Integer (boolean). - -* Description: -* This attribute indicates whether the FrameSet encapsulated by the -* Region should be included in the dump produced by the Dump function. -* -* If set to a non-zero value (the default), the FrameSet in the Region -* will always be included in the dump as usual. If set to zero, the -* FrameSet will only be included in the dump if the Mapping from base -* to current Frame is not a UnitMap. If the base->current Mapping is -* a UnitMap, the FrameSet is omitted from the dump. If the dump is -* subsequently used to re-create the Region, the new Region will have a -* default FrameSet containing a single default Frame with the appropriate -* number of axes. -* -* This facility is indended to reduce the size of textual dumps of -* Regions in situations where the Frame to which the Region refers can -* be implied by the context in which the Region is used. This is -* often the case when a Region is encapsulated within another Region. -* In such cases the current Frame of the encapsulated Region will -* usually be equivalent to the base Frame of the parent Region -* structure, and so can be re-instated (by calling the astSetRegFS -* method) even if the FrameSet is omitted from the dump of the -* encapsulated Region. Note if the base->current Mapping in the FrameSet -* in the encapsulated Region is not a UnitMap, then we should always -* dump the FrameSet regardless of the setting of RegionFS. This is because -* the parent Region structure will not know how to convert the PointSet -* stored in the encapsulated Region into its own base Frame if the -* FrameSet is not available. - -* Applicability: -* Region -* All Regions have this attribute. -*att- -*/ - -/* This is a boolean value (0 or 1) with a value of -INT_MAX when - undefined but yielding a default of one. */ -astMAKE_CLEAR(Region,RegionFS,regionfs,-INT_MAX) -astMAKE_TEST(Region,RegionFS,( this->regionfs != -INT_MAX )) -astMAKE_SET(Region,RegionFS,int,regionfs,( value != 0 )) -astMAKE_GET(Region,RegionFS,int,1,( ( this->regionfs == -INT_MAX ) ? - 1 : this->regionfs )) - -/* -*att++ -* Name: -* FillFactor - -* Purpose: -* Fraction of the Region which is of interest. - -* Type: -* Public attribute. - -* Synopsis: -* Floating point. - -* Description: -* This attribute indicates the fraction of the Region which is of -* interest. AST does not use this attribute internally for any purpose. -* Typically, it could be used to indicate the fraction of the Region for -* which data is available. -* -* The supplied value must be in the range 0.0 to 1.0, and the default -* value is 1.0 (except as noted below). - -* Applicability: -* Region -* All Regions have this attribute. -* CmpRegion -* The default FillFactor for a CmpRegion is the FillFactor of its -* first component Region. -* Prism -* The default FillFactor for a Prism is the product of the -* FillFactors of its two component Regions. -* Stc -* The default FillFactor for an Stc is the FillFactor of its -* encapsulated Region. -*att-- -*/ - -astMAKE_CLEAR(Region,FillFactor,fillfactor,AST__BAD) -astMAKE_GET(Region,FillFactor,double,1.0,( ( this->fillfactor == AST__BAD ) ? - 1.0 : this->fillfactor )) -astMAKE_TEST(Region,FillFactor,( this->fillfactor != AST__BAD )) -astMAKE_SET(Region,FillFactor,double,fillfactor,((value<0.0||value>1.0)?( - astError(AST__ATSER,"astSetFillFactor(%s): Invalid value (%g) supplied " - "for attribute FillFactor.", status,astGetClass(this),value), - astError(AST__ATSER,"FillFactor values should be in the range 0.0 to 1.0", status), - this->fillfactor):value)) - -/* -*att++ -* Name: -* MeshSize - -* Purpose: -* Number of points used to represent the boundary of a Region. - -* Type: -* Public attribute. - -* Synopsis: -* Integer. - -* Description: -* This attribute controls how many points are used when creating a -* mesh of points covering the boundary or volume of a Region. Such a -* mesh is returned by the -c astGetRegionMesh -f AST_GETREGIONMESH -* method. The boundary mesh is also used when testing for overlap -* between two Regions: each point in the bomdary mesh of the first -* Region is checked to see if it is inside or outside the second Region. -* Thus, the reliability of the overlap check depends on the value assigned -* to this attribute. If the value used is very low, it is possible for -* overlaps to go unnoticed. High values produce more reliable results, but -* can result in the overlap test being very slow. The default value is 200 -* for two dimensional Regions and 2000 for three or more dimensional -* Regions (this attribute is not used for 1-dimensional regions since the -* boundary of a simple 1-d Region can only ever have two points). A -* value of five is used if the supplied value is less than five. - -* Applicability: -* Region -* All Regions have this attribute. -* CmpRegion -* The default MeshSize for a CmpRegion is the MeshSize of its -* first component Region. -* Stc -* The default MeshSize for an Stc is the MeshSize of its -* encapsulated Region. -*att-- -*/ -/* If the value of MeshSize is set or cleared, annul the PointSet used to - cache a mesh of base Frame boundary points. This will force a new - PointSet to be created next time it is needed. See function RegMesh. */ -astMAKE_CLEAR(Region,MeshSize,meshsize,(astResetCache(this),-INT_MAX)) -astMAKE_SET(Region,MeshSize,int,meshsize,(astResetCache(this),( value > 5 ? value : 5 ))) -astMAKE_TEST(Region,MeshSize,( this->meshsize != -INT_MAX )) -astMAKE_GET(Region,MeshSize,int,0,( ( this->meshsize == -INT_MAX)?((astGetNaxes(this)==1)?2:((astGetNaxes(this)==2)?200:2000)): this->meshsize )) - -/* -*att++ -* Name: -* Closed - -* Purpose: -* Should the boundary be considered to be inside the region? - -* Type: -* Public attribute. - -* Synopsis: -* Integer (boolean). - -* Description: -* This attribute controls whether points on the boundary of a Region -* are considered to be inside or outside the region. If the attribute -* value is non-zero (the default), points on the boundary are considered -* to be inside the region (that is, the Region is "closed"). However, -* if the attribute value is zero, points on the bounary are considered -* to be outside the region. - -* Applicability: -* Region -* All Regions have this attribute. -* PointList -* The value of the Closed attribute is ignored by PointList regions. -* If the PointList region has not been negated, then it is always -* assumed to be closed. If the PointList region has been negated, then -* it is always assumed to be open. This is required since points -* have zero volume and therefore consist entirely of boundary. -* CmpRegion -* The default Closed value for a CmpRegion is the Closed value of its -* first component Region. -* Stc -* The default Closed value for an Stc is the Closed value of its -* encapsulated Region. -*att-- -*/ -/* This is a boolean value (0 or 1) with a value of -INT_MAX when - undefined but yielding a default of 1. */ -astMAKE_CLEAR(Region,Closed,closed,(astResetCache(this),-INT_MAX)) -astMAKE_GET(Region,Closed,int,1,( ( this->closed == -INT_MAX ) ? - 1 : this->closed )) -astMAKE_SET(Region,Closed,int,closed,(astResetCache(this),( value != 0 ))) -astMAKE_TEST(Region,Closed,( this->closed != -INT_MAX )) - -/* Access to attributes of the encapsulated Frame. */ -/* ----------------------------------------------- */ -/* Use the macros defined at the start of this file to implement - private member functions that give access to the attributes of the - encapsulated Frame of a Region and its axes. These functions over-ride - the attribute access methods inherited from the Frame class. */ - -/* Clear, Get, Set and Test axis-independent Frame attributes. */ -MAKE_CLEAR(Digits) -MAKE_CLEAR(Domain) -MAKE_CLEAR(MatchEnd) -MAKE_CLEAR(MaxAxes) -MAKE_CLEAR(MinAxes) -MAKE_CLEAR(Permute) -MAKE_CLEAR(PreserveAxes) -MAKE_CLEAR(Title) - -MAKE_GET(Digits,int) -MAKE_GET(Domain,const char *) -MAKE_GET(MatchEnd,int) -MAKE_GET(MaxAxes,int) -MAKE_GET(MinAxes,int) -MAKE_GET(Permute,int) -MAKE_GET(PreserveAxes,int) -MAKE_GET(Title,const char *) -MAKE_SET(Digits,int,I) -MAKE_SET(Domain,const char *,C) -MAKE_SET(MatchEnd,int,I) -MAKE_SET(MaxAxes,int,I) -MAKE_SET(MinAxes,int,I) -MAKE_SET(Permute,int,I) -MAKE_SET(PreserveAxes,int,I) -MAKE_SET(Title,const char *,C) -MAKE_TEST(Digits) -MAKE_TEST(Domain) -MAKE_TEST(MatchEnd) -MAKE_TEST(MaxAxes) -MAKE_TEST(MinAxes) -MAKE_TEST(Permute) -MAKE_TEST(PreserveAxes) -MAKE_TEST(Title) - -MAKE_GET(ActiveUnit,int) -MAKE_SET(ActiveUnit,int,I) -MAKE_TEST(ActiveUnit) - -MAKE_GET(System,AstSystemType) -MAKE_SET_SYSTEM(System) -MAKE_TEST(System) -MAKE_CLEAR(System) - -MAKE_GET(AlignSystem,AstSystemType) -MAKE_SET_SYSTEM(AlignSystem) -MAKE_TEST(AlignSystem) -MAKE_CLEAR(AlignSystem) - -MAKE_GET(Epoch,double) -MAKE_SET(Epoch,double,D) -MAKE_TEST(Epoch) -MAKE_CLEAR(Epoch) - -MAKE_GET(ObsLon,double) -MAKE_SET(ObsLon,double,D) -MAKE_TEST(ObsLon) -MAKE_CLEAR(ObsLon) - -MAKE_GET(ObsLat,double) -MAKE_SET(ObsLat,double,D) -MAKE_TEST(ObsLat) -MAKE_CLEAR(ObsLat) - -MAKE_GET(ObsAlt,double) -MAKE_SET(ObsAlt,double,D) -MAKE_TEST(ObsAlt) -MAKE_CLEAR(ObsAlt) - -/* Clear, Get, Set and Test axis-dependent Frame attributes. */ -MAKE_CLEAR_AXIS(Direction) -MAKE_CLEAR_AXIS(Format) -MAKE_CLEAR_AXIS(Label) -MAKE_CLEAR_AXIS(Symbol) -MAKE_CLEAR_AXIS(Unit) -MAKE_GET_AXIS(Direction,int) -MAKE_GET_AXIS(Format,const char *) -MAKE_GET_AXIS(Label,const char *) -MAKE_GET_AXIS(Symbol,const char *) -MAKE_GET_AXIS(Unit,const char *) -MAKE_SET_AXIS(Direction,int,I) -MAKE_SET_AXIS(Format,const char *,C) -MAKE_SET_AXIS(Label,const char *,C) -MAKE_SET_AXIS(Symbol,const char *,C) -MAKE_SET_AXIS(Unit,const char *,C) -MAKE_TEST_AXIS(Direction) -MAKE_TEST_AXIS(Format) -MAKE_TEST_AXIS(Label) -MAKE_TEST_AXIS(Symbol) -MAKE_TEST_AXIS(Unit) - -MAKE_GET_AXIS(Bottom,double) -MAKE_SET_AXIS(Bottom,double,D) -MAKE_TEST_AXIS(Bottom) -MAKE_CLEAR_AXIS(Bottom) - -MAKE_GET_AXIS(Top,double) -MAKE_SET_AXIS(Top,double,D) -MAKE_TEST_AXIS(Top) -MAKE_CLEAR_AXIS(Top) - -/* Copy constructor. */ -/* ----------------- */ -static void Copy( const AstObject *objin, AstObject *objout, int *status ) { -/* -* Name: -* Copy - -* Purpose: -* Copy constructor for Region objects. - -* Type: -* Private function. - -* Synopsis: -* void Copy( const AstObject *objin, AstObject *objout, int *status ) - -* Description: -* This function implements the copy constructor for Region objects. - -* Parameters: -* objin -* Pointer to the object to be copied. -* objout -* Pointer to the object being constructed. -* status -* Pointer to the inherited status variable. - -* Notes: -* - This constructor makes a deep copy. -*/ - -/* Local Variables: */ - AstRegion *in; /* Pointer to input Region */ - AstRegion *out; /* Pointer to output Region */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain pointers to the input and output Regions. */ - in = (AstRegion *) objin; - out = (AstRegion *) objout; - -/* For safety, first clear any references to the input memory from - the output Region. */ - out->basemesh = NULL; - out->basegrid = NULL; - out->frameset = NULL; - out->points = NULL; - out->unc = NULL; - out->negation = NULL; - out->defunc = NULL; - -/* Now copy each of the above structures. */ - out->frameset = astCopy( in->frameset ); - if( in->points ) out->points = astCopy( in->points ); - if( in->basemesh ) out->basemesh = astCopy( in->basemesh ); - if( in->basegrid ) out->basegrid = astCopy( in->basegrid ); - if( in->unc ) out->unc = astCopy( in->unc ); - if( in->negation ) out->negation = astCopy( in->negation ); - if( in->defunc ) out->defunc = astCopy( in->defunc ); -} - - -/* Destructor. */ -/* ----------- */ -static void Delete( AstObject *obj, int *status ) { -/* -* Name: -* Delete - -* Purpose: -* Destructor for Region objects. - -* Type: -* Private function. - -* Synopsis: -* void Delete( AstObject *obj, int *status ) - -* Description: -* This function implements the destructor for Region objects. - -* Parameters: -* obj -* Pointer to the object to be deleted. -* status -* Pointer to the inherited status variable. - -* Notes: -* This function attempts to execute even if the global error status is -* set. -*/ - -/* Local Variables: */ - AstRegion *this; /* Pointer to Region */ - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) obj; - -/* Annul all resources. */ - this->frameset = astAnnul( this->frameset ); - if( this->points ) this->points = astAnnul( this->points ); - if( this->basemesh ) this->basemesh = astAnnul( this->basemesh ); - if( this->basegrid ) this->basegrid = astAnnul( this->basegrid ); - if( this->unc ) this->unc = astAnnul( this->unc ); - if( this->negation ) this->negation = astAnnul( this->negation ); - if( this->defunc ) this->defunc = astAnnul( this->defunc ); -} - -/* Dump function. */ -/* -------------- */ -static void Dump( AstObject *this_object, AstChannel *channel, int *status ) { -/* -* Name: -* Dump - -* Purpose: -* Dump function for Region objects. - -* Type: -* Private function. - -* Synopsis: -* void Dump( AstObject *this, AstChannel *channel, int *status ) - -* Description: -* This function implements the Dump function which writes out data -* for the Region class to an output Channel. - -* Parameters: -* this -* Pointer to the Region whose data are being written. -* channel -* Pointer to the Channel to which the data are being written. -* status -* Pointer to the inherited status variable. -*/ - -/* Local Constants: */ -#define KEY_LEN 50 /* Maximum length of a keyword */ -#define COM_LEN 50 /* Maximum length of a comment */ - -/* Local Variables: */ - AstFrame *fr; /* Pointer to the current Frame */ - AstMapping *smap; /* Base->current Mapping */ - AstRegion *this; /* Pointer to the Region structure */ - AstRegion *unc; /* Pointer to the uncertainty Region */ - double dval; /* Floating point attribute value */ - int ival; /* Integer attribute value */ - int set; /* Attribute value set? */ - int unit; /* Base->current is unitmap? */ - -/* Check the global error status. */ - if ( !astOK ) return; - -/* Obtain a pointer to the Region structure. */ - this = (AstRegion *) this_object; - -/* Write out values representing the instance variables for the - Region class. Accompany these with appropriate comment strings, - possibly depending on the values being written.*/ - -/* In the case of attributes, we first use the appropriate (private) - Test... member function to see if they are set. If so, we then use - the (private) Get... function to obtain the value to be written - out. - - For attributes which are not set, we use the astGet... method to - obtain the value instead. This will supply a default value - (possibly provided by a derived class which over-rides this method) - which is more useful to a human reader as it corresponds to the - actual default attribute value. Since "set" will be zero, these - values are for information only and will not be read back. */ - -/* Negated. */ -/* -------- */ - set = TestNegated( this, status ); - ival = set ? GetNegated( this, status ) : astGetNegated( this ); - astWriteInt( channel, "Negate", (ival != 0), 0, ival, - ival ? "Region negated" : "Region not negated" ); - -/* FillFactor */ -/* ---------- */ - set = TestFillFactor( this, status ); - dval = set ? GetFillFactor( this, status ) : astGetFillFactor( this ); - astWriteDouble( channel, "Fill", set, 0, dval,"Region fill factor" ); - -/* MeshSize. */ -/* --------- */ - set = TestMeshSize( this, status ); - ival = set ? GetMeshSize( this, status ) : astGetMeshSize( this ); - astWriteInt( channel, "MeshSz", set, 0, ival, - "No. of points used to represent boundary" ); - -/* Closed. */ -/* ------- */ - set = TestClosed( this, status ); - ival = set ? GetClosed( this, status ) : astGetClosed( this ); - astWriteInt( channel, "Closed", set, 0, ival, - ival ? "Boundary is inside" : "Boundary is outside" ); - -/* Adaptive */ -/* -------- */ - set = TestAdaptive( this, status ); - ival = set ? GetAdaptive( this, status ) : astGetAdaptive( this ); - astWriteInt( channel, "Adapt", (ival != 0), 0, ival, - ival ? "Region adapts to coord sys changes" : "Region does not adapt to coord sys changes" ); - -/* FrameSet */ -/* -------- */ - -/* If the vertices are the same in both base and current Frames (i.e. - if the Frames are connected by a UnitMap), then just dump the current - Frame (unless the RegionFS attribute is zero, in which case the - current Frame can be determined from the higher level context of the - Region and so does not need to be dumped- e.g. if the Region is contained - within another Region the parent Region will define the current Frame). - Otherwise, dump the whole FrameSet. */ - ival = astGetRegionFS( this ); - smap = astRegMapping( this ); - if( ( unit = astIsAUnitMap( smap ) ) ){ - set = 0; - if( ival ) { - fr = astGetFrame( this->frameset, AST__CURRENT ); - astWriteObject( channel, "Frm", 1, 1, fr, "Coordinate system" ); - fr = astAnnul( fr ); - } - } else { - set = ( ival == 0 ); - astWriteObject( channel, "FrmSet", 1, 1, this->frameset, - "Original & current coordinate systems" ); - } - -/* Annul the Mapping pointers */ - smap = astAnnul( smap ); - -/* RegionFS */ -/* -------- */ - astWriteInt( channel, "RegFS", set, 0, ival, - ival ? "Include Frame in dump" : "Do not include Frame in dump" ); - -/* Points */ -/* ------ */ - if( this->points ) { - astWriteObject( channel, "Points", 1, 1, this->points, - "Points defining the shape" ); - -/* If the FrameSet was not included in the dump, then the loader will use - the PointSet to determine the number of axes in the frame spanned by - the Region. If there is no PointSet, then we must explicitly include - an item giving the number of axes.*/ - } else { - astWriteInt( channel, "RegAxes", 1, 1, astGetNaxes( this ), - "Number of axes spanned by the Region" ); - } - -/* Uncertainty */ -/* ----------- */ -/* Only dump the uncertinaty Region if required. */ - if( astTestUnc( this ) ) { - unc = astGetUncFrm( this, AST__BASE ); - astWriteObject( channel, "Unc", 1, 1, unc, - "Region defining positional uncertainties." ); - unc = astAnnul( unc ); - } - -/* Undefine macros local to this function. */ -#undef KEY_LEN -} - - -/* Standard class functions. */ -/* ========================= */ -/* Implement the astIsARegion and astCheckRegion functions using - the macros defined for this purpose in the "object.h" header - file. */ -astMAKE_ISA(Region,Frame) -astMAKE_CHECK(Region) - -AstRegion *astInitRegion_( void *mem, size_t size, int init, - AstRegionVtab *vtab, const char *name, - AstFrame *frame, AstPointSet *pset, - AstRegion *unc, int *status ){ -/* -*+ -* Name: -* astInitRegion - -* Purpose: -* Initialise a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *astInitRegion( void *mem, size_t size, int init, -* AstRegionVtab *vtab, const char *name, -* AstFrame *frame, AstpointSet *pset, -* AstRegion *unc ) - -* Class Membership: -* Region initialiser. - -* Description: -* This function is provided for use by class implementations to -* initialise a new Region object. It allocates memory (if -* necessary) to accommodate the Region plus any additional data -* associated with the derived class. It then initialises a -* Region structure at the start of this memory. If the "init" -* flag is set, it also initialises the contents of a virtual -* function table for a Region at the start of the memory passed -* via the "vtab" parameter. - -* Parameters: -* mem -* A pointer to the memory in which the Region is to be -* created. This must be of sufficient size to accommodate the -* Region data (sizeof(Region)) plus any data used by the -* derived class. If a value of NULL is given, this function -* will allocate the memory itself using the "size" parameter to -* determine its size. -* size -* The amount of memory used by the Region (plus derived class -* data). This will be used to allocate memory if a value of -* NULL is given for the "mem" parameter. This value is also -* stored in the Region structure, so a valid value must be -* supplied even if not required for allocating memory. -* init -* A logical flag indicating if the Region's virtual function -* table is to be initialised. If this value is non-zero, the -* virtual function table will be initialised by this function. -* vtab -* Pointer to the start of the virtual function table to be -* associated with the new Region. -* name -* Pointer to a constant null-terminated character string which -* contains the name of the class to which the new object -* belongs (it is this pointer value that will subsequently be -* returned by the astGetClass method). -* frame -* Pointer to the encapsulated Frame. A deep copy of this Frame is -* taken. This means that subsequent changes to the supplied Frame -* will have no effect on the new Region. -* pset -* A PointSet holding the points which define the Region. These -* positions should refer to the given Frame. May be NULL. -* unc -* A pointer to a Region which specifies the uncertainty in the -* supplied positions (all points on the boundary of the new Region -* being initialised are assumed to have the same uncertainty). A NULL -* pointer can be supplied, in which case default uncertainties equal to -* 1.0E-6 of the dimensions of the new Region's bounding box are used. -* If an uncertainty Region is supplied, it must be of a class for -* which all instances are centro-symetric (e.g. Box, Circle, Ellipse, -* etc.) or be a Prism containing centro-symetric component Regions. -* Its encapsulated Frame must be related to the Frame supplied for -* parameter "frame" (i.e. astConvert should be able to find a Mapping -* between them). Two positions in the "frame" Frame are considered to be -* co-incident if their uncertainty Regions overlap. The centre of the -* supplied uncertainty Region is immaterial since it will be re-centred -* on the point being tested before use. A deep copy is taken of the -* supplied Region. - -* Returned Value: -* A pointer to the new Region. - -* Notes: -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Variables: */ - AstFrame *f0; /* Frame to use */ - AstRegion *new; /* Pointer to new Region */ - int nax; /* No. of axes in supplied Frame */ - int ncoord; /* Coords per point */ - -/* Check the global status. */ - if ( !astOK ) return NULL; - -/* If necessary, initialise the virtual function table. */ - if( init ) astInitRegionVtab( vtab, name ); - -/* Note the number of axes in the supplied Frame. */ - nax = astGetNaxes( frame ); - -/* Check the pointset if supplied. */ - if( pset ) { - -/* Note the number of axes per point in the supplied PointSet */ - ncoord = astGetNcoord( pset ); - -/* If OK, check that the number of coordinates per point matches the number - of axes in the Frame. Report an error if these numbers do not match. */ - if ( astOK && ( ncoord != nax ) ) { - astError( AST__NCPIN, "astInitRegion(%s): Bad number of coordinate " - "values per point (%d).", status, name, ncoord ); - astError( AST__NCPIN, "The %s given requires %d coordinate value(s) " - "for each point.", status, astGetClass( frame ), nax ); - } - } - -/* Initialise a Frame structure (the parent class) as the first - component within the Region structure, allocating memory if - necessary. Give this Frame zero axes as the Frame information will be - specified by the encapsulated FrameSet. */ - new = (AstRegion *) astInitFrame( mem, size, 0, (AstFrameVtab *) vtab, - name, 0 ); - if ( astOK ) { - -/* Initialise the Region data. */ -/* ----------------------------- */ - new->frameset = NULL; - new->points = NULL; - new->unc = NULL; - new->meshsize = -INT_MAX; - new->adaptive = -INT_MAX; - new->basemesh = NULL; - new->basegrid = NULL; - new->negated = -INT_MAX; - new->closed = -INT_MAX; - new->regionfs = -INT_MAX; - new->fillfactor = AST__BAD; - new->defunc = NULL; - new->nomap = 0; - new->negation = NULL; - -/* If the supplied Frame is a Region, gets its encapsulated Frame. If a - FrameSet was supplied, use its current Frame, otherwise use the - supplied Frame. */ - if( astIsARegion( frame ) ) { - f0 = astGetFrame( ((AstRegion *) frame)->frameset, AST__CURRENT ); - - } else if( astIsAFrameSet( frame ) ) { - f0 = astGetFrame( (AstFrameSet *) frame, AST__CURRENT ); - - } else { - f0 = astClone( frame ); - } - -/* Store a clone of the supplied PointSet pointer. */ - new->points = pset ? astClone( pset ) : NULL; - - -#ifdef DEBUG - if( pset ) { - double **ptr; - double lim; - int ii,jj, np; - ptr = astGetPoints( pset ); - np = astGetNpoint( pset ); - lim = sqrt( DBL_MAX ); - for( ii = 0; astOK && ii < ncoord; ii++ ) { - for( jj = 0; jj < np; jj++ ) { - if( fabs( ptr[ ii ][ jj ] ) > lim ) { - if( !strcmp( name, "Interval" ) ) { - if( ptr[ ii ][ jj ] != AST__BAD && - ptr[ ii ][ jj ] != DBL_MAX && - ptr[ ii ][ jj ] != -DBL_MAX ) { - astError( AST__INTER, "astInitRegion(%s): suspicious " - "axis value (%g) supplied.", status, name, ptr[ ii ][ jj ] ); - break; - } - } else { - astError( AST__INTER, "astInitRegion(%s): suspicious " - "axis value (%g) supplied.", status, name, - ptr[ ii ][ jj ] ); - break; - } - } - } - } - } -#endif - -/* Form a FrameSet consisting of two copies of the supplied Frame connected - together by a UnitMap, and store in the Region structure. We use the - private SetRegFS rather than the protected astSetRegFS because this - initialiser may be being called from a subclass which over-rides - astSetRegFS. If this were the case, then the implementation of - astSetRegFS provided by the subclass may access information within the - subclass structure which has not yet been initialised. */ - SetRegFS( new, f0, status ); - f0 = astAnnul( f0 ); - -/* Store any uncertainty Region. Use the private SetUnc rather than - astSetUnc to avoid subclass implementations using subclass data which - has not yet been initialised. */ - SetUnc( new, unc, status ); - -/* If an error occurred, clean up by deleting the new object. */ - if ( !astOK ) new = astDelete( new ); - } - -/* Return a pointer to the new object. */ - return new; -} - -AstRegion *astLoadRegion_( void *mem, size_t size, - AstRegionVtab *vtab, const char *name, - AstChannel *channel, int *status ) { -/* -*+ -* Name: -* astLoadRegion - -* Purpose: -* Load a Region. - -* Type: -* Protected function. - -* Synopsis: -* #include "region.h" -* AstRegion *astLoadRegion( void *mem, size_t size, -* AstRegionVtab *vtab, const char *name, -* AstChannel *channel ) - -* Class Membership: -* Region loader. - -* Description: -* This function is provided to load a new Region using data read -* from a Channel. It first loads the data used by the parent class -* (which allocates memory if necessary) and then initialises a -* Region structure in this memory, using data read from the -* input Channel. - -* Parameters: -* mem -* A pointer to the memory into which the Region is to be -* loaded. This must be of sufficient size to accommodate the -* Region data (sizeof(Region)) plus any data used by -* derived classes. If a value of NULL is given, this function -* will allocate the memory itself using the "size" parameter to -* determine its size. -* size -* The amount of memory used by the Region (plus derived class -* data). This will be used to allocate memory if a value of -* NULL is given for the "mem" parameter. This value is also -* stored in the Region structure, so a valid value must be -* supplied even if not required for allocating memory. -* -* If the "vtab" parameter is NULL, the "size" value is ignored -* and sizeof(AstRegion) is used instead. -* vtab -* Pointer to the start of the virtual function table to be -* associated with the new Region. If this is NULL, a pointer -* to the (static) virtual function table for the Region class -* is used instead. -* name -* Pointer to a constant null-terminated character string which -* contains the name of the class to which the new object -* belongs (it is this pointer value that will subsequently be -* returned by the astGetClass method). -* -* If the "vtab" parameter is NULL, the "name" value is ignored -* and a pointer to the string "Region" is used instead. - -* Returned Value: -* A pointer to the new Region. - -* Notes: -* - A null pointer will be returned if this function is invoked -* with the global error status set, or if it should fail for any -* reason. -*- -*/ - -/* Local Constants: */ - astDECLARE_GLOBALS /* Pointer to thread-specific global data */ -#define KEY_LEN 50 /* Maximum length of a keyword */ - -/* Local Variables: */ - AstFrame *f1; /* Base Frame for encapsulated FrameSet */ - AstRegion *new; /* Pointer to the new Region */ - int nax; /* No. of axes in Frame, or FrameSet base Frame */ - int naxpt; /* No. of axes in per point */ - -/* Get a pointer to the thread specific global data structure. */ - astGET_GLOBALS(channel); - -/* Initialise. */ - new = NULL; - -/* Check the global error status. */ - if ( !astOK ) return new; - -/* If a NULL virtual function table has been supplied, then this is - the first loader to be invoked for this Region. In this case the - Region belongs to this class, so supply appropriate values to be - passed to the parent class loader (and its parent, etc.). */ - if ( !vtab ) { - size = sizeof( AstRegion ); - vtab = &class_vtab; - name = "Region"; - -/* If required, initialise the virtual function table for this class. */ - if ( !class_init ) { - astInitRegionVtab( vtab, name ); - class_init = 1; - } - } - -/* Invoke the parent class loader to load data for all the ancestral - classes of the current one, returning a pointer to the resulting - partly-built Region. */ - new = astLoadFrame( mem, size, (AstFrameVtab *) vtab, name, - channel ); - - if ( astOK ) { - -/* Read input data. */ -/* ================ */ -/* Request the input Channel to read all the input data appropriate to - this class into the internal "values list". */ - astReadClassData( channel, "Region" ); - -/* Now read each individual data item from this list and use it to - initialise the appropriate instance variable(s) for this class. */ - -/* In the case of attributes, we first read the "raw" input value, - supplying the "unset" value as the default. If a "set" value is - obtained, we then use the appropriate (private) Set... member - function to validate and set the value properly. */ - -/* Negated */ -/* ------- */ - new->negated = astReadInt( channel, "negate", -INT_MAX ); - if ( TestNegated( new, status ) ) SetNegated( new, new->negated, status ); - -/* FillFactor */ -/* ---------- */ - new->fillfactor = astReadDouble( channel, "fill", AST__BAD ); - if ( TestFillFactor( new, status ) ) SetFillFactor( new, new->fillfactor, status ); - -/* MeshSize */ -/* -------- */ - new->meshsize = astReadInt( channel, "meshsz", -INT_MAX ); - if ( TestMeshSize( new, status ) ) SetMeshSize( new, new->meshsize, status ); - -/* Closed */ -/* ------ */ - new->closed = astReadInt( channel, "closed", -INT_MAX ); - if ( TestClosed( new, status ) ) SetClosed( new, new->closed, status ); - -/* Adaptive */ -/* -------- */ - new->adaptive = astReadInt( channel, "adapt", -INT_MAX ); - if ( TestAdaptive( new, status ) ) SetAdaptive( new, new->adaptive, status ); - -/* Points */ -/* ------ */ - new->points = astReadObject( channel, "points", NULL ); - -/* If some points were found, ensure that they are in a PointSet and get - the number of axis values per point. */ - if( new->points ){ - if( astIsAPointSet( new->points) ) { - naxpt = astGetNcoord( new->points ); - } else { - naxpt = 0; - astError( AST__REGIN, "astLoadRegion(%s): Corrupt %s specifies points " - "using a %s (should be a PointSet).", status, astGetClass( new ), - astGetClass( new ), astGetClass( new->points ) ); - } - -/* If no PointSet was loaded, attempt to determine the number of axes - spanned by the Region by reading the RegAxes value. */ - } else { - naxpt = astReadInt( channel, "regaxes", 0 ); - } - -/* Uncertainty */ -/* ----------- */ - new->unc = astReadObject( channel, "unc", NULL ); - new->defunc = NULL; - -/* FrameSet */ -/* -------- */ -/* First see if the dump contains a single Frame. If so, create a - FrameSet from it and a copy of itself, using a UnitMap to connect the - two. */ - new->nomap = 0; - new->frameset = NULL; - f1 = astReadObject( channel, "frm", NULL ); - if( f1 ) { - new->regionfs = 1; - nax = astGetNaxes( f1 ); - astSetRegFS( new, f1 ); - f1 = astAnnul( f1 ); - -/* If no Frame was found in the dump, look for a FrameSet. Get the number - of axes spanning its base Frame ("Nin"). */ - } else { - new->frameset = astReadObject( channel, "frmset", NULL ); - if( new->frameset ) { - nax = astGetNin( new->frameset ); - -/* If a FrameSet was found, the value of the RegionFS attribute is still - unknown and so we must read it from an attribute as normal. */ - new->regionfs = astReadInt( channel, "regfs", 1 ); - if ( TestRegionFS( new, status ) ) SetRegionFS( new, new->regionfs, status ); - - } else { - nax = 0; - } - } - -/* If neither a Frame nor a FrameSet was found, create a default FrameSet - and set the RegionFS attribute false, to indicate that the FrameSet - should not be used. */ - if( !new->frameset ){ - nax = naxpt ? naxpt : 1; - f1 = astFrame( nax, "", status ); - new->frameset = astFrameSet( f1, "", status ); - astSetIdent( new->frameset, DUMMY_FS ); - f1 = astAnnul( f1 ); - new->regionfs = 0; - } - -/* Report an error if the number of axis values per point in the pointset is - incorrect. */ - if ( astOK && new->points && ( naxpt != nax ) ) { - astError( AST__REGIN, "astLoadRegion(%s): Corrupt %s contains " - " incorrect number of coordinate values per point (%d).", status, - astGetClass( new ), astGetClass( new ), naxpt ); - astError( AST__REGIN, "The %s requires %d coordinate value(s) " - "for each point.", status, astGetClass( new ), nax ); - } - -/* Initialise other fields which are used as caches for values derived - from the attributes set above. */ - new->basemesh = NULL; - new->basegrid = NULL; - -/* If an error occurred, clean up by deleting the new Region. */ - if ( !astOK ) new = astDelete( new ); - } - -/* Return the new Region pointer. */ - return new; - -/* Undefine macros local to this function. */ -#undef KEY_LEN -} - -/* Virtual function interfaces. */ -/* ============================ */ -/* These provide the external interface to the virtual functions defined by - this class. Each simply checks the global error status and then locates and - executes the appropriate member function, using the function pointer stored - in the object's virtual function table (this pointer is located using the - astMEMBER macro defined in "object.h"). - - Note that the member function may not be the one defined here, as it may - have been over-ridden by a derived class. However, it should still have the - same interface. */ - -void astRegClearAttrib_( AstRegion *this, const char *attrib, char **base_attrib, int *status ) { - if ( !astOK ) return; - (**astMEMBER(this,Region,RegClearAttrib))( this, attrib, base_attrib, status ); -} -void astRegSetAttrib_( AstRegion *this, const char *setting, char **base_setting, int *status ) { - if ( !astOK ) return; - (**astMEMBER(this,Region,RegSetAttrib))( this, setting, base_setting, status ); -} -void astNegate_( AstRegion *this, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,Negate))( this, status ); -} -AstFrame *astGetRegionFrame_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetRegionFrame))( this, status ); -} -AstFrameSet *astGetRegionFrameSet_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetRegionFrameSet))( this, status ); -} -AstRegion *astMapRegion_( AstRegion *this, AstMapping *map, AstFrame *frame, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,MapRegion))( this, map, frame, status ); -} -int astOverlap_( AstRegion *this, AstRegion *that, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,Overlap))( this, that, status ); -} -int astOverlapX_( AstRegion *that, AstRegion *this, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(that,Region,OverlapX))( that, this, status ); -} -AstFrame *astRegFrame_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegFrame))( this, status ); -} -AstRegion *astRegBasePick_( AstRegion *this, int naxes, const int *axes, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegBasePick))( this, naxes, axes, status ); -} -AstPointSet *astBTransform_( AstRegion *this, AstPointSet *in, - int forward, AstPointSet *out, int *status ) { - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,BTransform))( this, in, forward, out, status ); -} -AstPointSet *astRegTransform_( AstRegion *this, AstPointSet *in, - int forward, AstPointSet *out, - AstFrame **frm, int *status ) { - if( frm ) *frm = NULL; - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegTransform))( this, in, forward, out, frm, status ); -} -int astRegPins_( AstRegion *this, AstPointSet *pset, AstRegion *unc, int **mask, int *status ){ - if( mask ) *mask = NULL; - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,RegPins))( this, pset, unc, mask, status ); -} -AstMapping *astRegMapping_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegMapping))( this, status ); -} -int astRegDummyFS_( AstRegion *this, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,RegDummyFS))( this, status ); -} -int astGetBounded_( AstRegion *this, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,GetBounded))( this, status ); -} -int astTestUnc_( AstRegion *this, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,TestUnc))( this, status ); -} -void astClearUnc_( AstRegion *this, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,ClearUnc))( this, status ); -} -void astRegBaseBox_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,RegBaseBox))( this, lbnd, ubnd, status ); -} -void astRegBaseBox2_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,RegBaseBox2))( this, lbnd, ubnd, status ); -} -void astResetCache_( AstRegion *this, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,ResetCache))( this, status ); -} -int astRegTrace_( AstRegion *this, int n, double *dist, double **ptr, int *status ){ - if ( !astOK ) return 0; - return (**astMEMBER(this,Region,RegTrace))( this, n, dist, ptr, status ); -} -void astGetRegionBounds_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,GetRegionBounds))( this, lbnd, ubnd, status ); -} -void astGetRegionMesh_( AstRegion *this, int surface, int maxpoint, - int maxcoord, int *npoint, double *points, - int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,GetRegionMesh))( this, surface, maxpoint, maxcoord, - npoint, points, status ); -} -void astGetRegionPoints_( AstRegion *this, int maxpoint, int maxcoord, - int *npoint, double *points, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,GetRegionPoints))( this, maxpoint, maxcoord, - npoint, points, status ); -} -void astShowMesh_( AstRegion *this, int format, const char *ttl, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,ShowMesh))( this, format,ttl, status ); -} -void astGetRegionBounds2_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,GetRegionBounds2))( this, lbnd, ubnd, status ); -} -void astRegOverlay_( AstRegion *this, AstRegion *that, int unc, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,RegOverlay))( this, that, unc, status ); -} -AstPointSet *astRegGrid_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegGrid))( this, status ); -} -AstPointSet *astRegMesh_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegMesh))( this, status ); -} -double *astRegCentre_( AstRegion *this, double *cen, double **ptr, int index, - int ifrm, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegCentre))( this, cen, ptr, index, ifrm, status ); -} -AstRegion *astGetNegation_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetNegation))( this, status ); -} -AstRegion *astGetUncFrm_( AstRegion *this, int ifrm, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetUncFrm))( this, ifrm, status ); -} -AstRegion *astGetDefUnc_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetDefUnc))( this, status ); -} -AstRegion *astGetUnc_( AstRegion *this, int def, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetUnc))( this, def, status ); -} -void astSetUnc_( AstRegion *this, AstRegion *unc, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,SetUnc))( this, unc, status ); -} -AstFrameSet *astGetRegFS_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,GetRegFS))( this, status ); -} -void astSetRegFS_( AstRegion *this, AstFrame *frm, int *status ){ - if ( !astOK ) return; - (**astMEMBER(this,Region,SetRegFS))( this, frm, status ); -} -AstPointSet *astRegBaseMesh_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegBaseMesh))( this, status ); -} -AstRegion **astRegSplit_( AstRegion *this, int *nlist, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegSplit))( this, nlist, status ); -} -AstPointSet *astRegBaseGrid_( AstRegion *this, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,RegBaseGrid))( this, status ); -} -AstPointSet *astBndBaseMesh_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,BndBaseMesh))( this, lbnd, ubnd, status ); -} -AstPointSet *astBndMesh_( AstRegion *this, double *lbnd, double *ubnd, int *status ){ - if ( !astOK ) return NULL; - return (**astMEMBER(this,Region,BndMesh))( this, lbnd, ubnd, status ); -} - -#define MAKE_MASK_(X,Xtype) \ -int astMask##X##_( AstRegion *this, AstMapping *map, int inside, int ndim, \ - const int lbnd[], const int ubnd[], Xtype in[], \ - Xtype val, int *status ) { \ - if ( !astOK ) return 0; \ - return (**astMEMBER(this,Region,Mask##X))( this, map, inside, ndim, lbnd, \ - ubnd, in, val, status ); \ -} -#if HAVE_LONG_DOUBLE /* Not normally implemented */ -MAKE_MASK_(LD,long double) -#endif -MAKE_MASK_(D,double) -MAKE_MASK_(F,float) -MAKE_MASK_(L,long int) -MAKE_MASK_(UL,unsigned long int) -MAKE_MASK_(I,int) -MAKE_MASK_(UI,unsigned int) -MAKE_MASK_(S,short int) -MAKE_MASK_(US,unsigned short int) -MAKE_MASK_(B,signed char) -MAKE_MASK_(UB,unsigned char) -#undef MAKE_MASK_ - -/* Special public interface functions. */ -/* =================================== */ -/* These provide the public interface to certain special functions - whose public interface cannot be handled using macros (such as - astINVOKE) alone. In general, they are named after the - corresponding protected version of the function, but with "Id" - appended to the name. */ - -/* Public Interface Function Prototypes. */ -/* ------------------------------------- */ -/* The following functions have public prototypes only (i.e. no - protected prototypes), so we must provide local prototypes for use - within this module. */ - -/* Special interface function implementations. */ -/* ------------------------------------------- */ - - -AstRegion *astMapRegionId_( AstRegion *this, AstMapping *map, AstFrame *frame, int *status ) { -/* -*++ -* Name: -c astMapRegion -f AST_MAPREGION - -* Purpose: -* Transform a Region into a new Frame using a given Mapping. - -* Type: -* Public virtual function. - -* Synopsis: -c #include "region.h" -c AstRegion *astMapRegion( AstRegion *this, AstMapping *map, -c AstFrame *frame ) -f RESULT = AST_MAPREGION( THIS, MAP, FRAME, STATUS ) - -* Class Membership: -* Region method. - -* Description: -* This function returns a pointer to a new Region which corresponds to -* supplied Region described by some other specified coordinate system. A -* Mapping is supplied which transforms positions between the old and new -* coordinate systems. The new Region may not be of the same class as -* the original region. - -* Parameters: -c this -f THIS = INTEGER (Given) -* Pointer to the Region. -c map -f MAP = INTEGER (Given) -* Pointer to a Mapping which transforms positions from the -* coordinate system represented by the supplied Region to the -* coordinate system specified by -c "frame". -f FRAME. -* The supplied Mapping should define both forward and inverse -* transformations, and these transformations should form a genuine -* inverse pair. That is, transforming a position using the forward -* transformation and then using the inverse transformation should -* produce the original input position. Some Mapping classes (such -* as PermMap, MathMap, SphMap) can result in Mappings for which this -* is not true. -c frame -f FRAME = INTEGER (Given) -* Pointer to a Frame describing the coordinate system in which -* the new Region is required. -f STATUS = INTEGER (Given and Returned) -f The global status. - -* Returned Value: -c astMapRegion() -f AST_MAPREGION = INTEGER -* A pointer to a new Region. This Region will represent the area -* within the coordinate system specified by -c "frame" -f FRAME -* which corresponds to the supplied Region. - -* Notes: -* - The uncertainty associated with the supplied Region is modified -* using the supplied Mapping. -* - A null Object pointer (AST__NULL) will be returned if this -c function is invoked with the AST error status set, or if it -f function is invoked with STATUS set to an error value, or if it -* should fail for any reason. -*-- - -* Implementation Notes: -* - The only difference between this public interface and the protected -* astMapRegion interface is that this implementation additionally -* simplifies the returned Region. The protected implementation does -* not do this since doing so can lead to infinite recursion because -* it is sometimes necessary for Simplify to call astMapRegion. - -*/ - -/* Local Variables: */ - AstRegion *new; /* Pointer to new Region */ - AstRegion *result; /* Pointer value to return */ - -/* Initialise. */ - result = NULL; - -/* Check the global error status. */ - if ( !astOK ) return result; - -/* Invoke the protected astMapRegion function. */ - new = astMapRegion( this, map, frame ); - -/* Simplify the resulting Region. */ - result = astSimplify( new ); - -/* Free resources. */ - new = astAnnul( new ); - -/* If not OK, annul the returned pointer. */ - if( !astOK ) result = astAnnul( result ); - -/* Return the result. */ - return result; -} - - - - - - - - - - - - |