POSC Specifications: Epicentre Version 3.0 | Logical Data Model |
This set of changes finalizes the convergence with the EPSG v5 data.
CHANGE ERP3_EPSG_coordinate_system ------------------------------------------------------------------------------- (*<CHANGE>Make the transformation parmameter a non-ref entity so that it is more visible. Make the other transformation entities match the EPSG name since there is no compelling reason to be different.*) ALTER ENTITY ref_coordinate_trfrm_parameter AS transformation_parameter (*<DESC>This specified the kinds of parameters used by coordinate transformation methods. Examples of these parameters are: scale factor, false easting, central meridian, rules, etc.*) DROP SUBTYPE OF (ref_code) ADD SUBTYPE OF (aliasable_technical_reference); INVERSE ALTER coordinate_trfrm_parameter AS parameter_usage (*<DESC>These are the usages of this parameter by a transformation method.*); END_ENTITY; ALTER ENTITY coordinate_trfrm_param_usage AS transformation_parameter_usage (*<DESC>The specification of a transformation parameter which is used by a transformation method.*); ALTER ref_coordinate_trfrm_parameter AS transformation_parameter (*<DESC>This is the parameter used in the transformation method.*); ALTER coordinate_trfrm_method AS transformation_method (*<DESC>This is the transformation method for which the parameter is defined.*); INVERSE ALTER coordinate_trfrm_value AS parameter_value; END_ENTITY; ALTER ENTITY coordinate_trfrm_method AS transformation_method; INVERSE ALTER coordinate_trfrm_param_usage AS parameter_usage (*<DESC>This indicates the set of parameters that are defined for use by this transformation method.*); END_ENTITY; ALTER ENTITY coordinate_trfrm_value AS transformation_parameter_value; INVERSE ALTER coordinate_trfrm_param_usage AS parameter_usage (*<DESC>This asserts the transformation parameter that provides the meaning and use of this value in the coordinate transformation.*); END_ENTITY; ALTER ENTITY ref_parameter_attribute; ALTER ref_coordinate_trfrm_parameter AS transformation_parameter; END_ENTITY; ALTER ENTITY coordinate_transformation_path AS transformation_path; END_ENTITY; ALTER ENTITY vertex; INVERSE ALTER coordinate_trfrm_value AS transformation_parameter_value (*<DESC>These are transformation values which utilize the location of the vertex.*); END_ENTITY; ALTER ENTITY coordinate_trfrm_earth_usage AS transformation_earth_usage (*<DESC>This association asserts that it is appropriate to use a coordinate transformation within a portion of the surface of the Earth.*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Make ref_transformation_parameter optional so that some parameters can be used with many types.*) ALTER ENTITY ref_coordinate_trfrm_parameter; ALTER ref_parameter_attribute ADD OPTIONAL (*<DESC>This designates the type of attribute in the transformation parameter value that should be used for this parameter. If not specified then an attribute of any type may be used for the parameter value (e.g., a parameter such as "A1" may be used in many contexts).*) (*<VERB>be constrained to*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Add source and target offset units to transformation.*) ALTER ENTITY coordinate_transformation; ADD source_offset_unit : OPTIONAL ref_unit_of_measure (*<DESC>This is the unit of measure of the input or source coordinate offsets from the evaluation point in a polynomial transformation. They are often different from the unit of measure of the coordinate system.*) (*<VERB>have source offset in*); ADD target_offset_unit : OPTIONAL ref_unit_of_measure (*<DESC>This is the unit of measure of the output or target coordinate offsets from the evaluation point in a polynomial transformation. They are often different from the unit of measure of the coordinate system.*) (*<VERB>have target offset in*); WHERE ADD val : (EXISTS(source_offset_unit) AND EXISTS(target_offset_unit)) OR ((NOT EXISTS(source_offset_unit)) AND (NOT EXISTS(target_offset_unit))) (*<DESC>If either of TARGET OFFSET UNIT or SOURCE OFFSET UNIT is specified then both must be specified.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY ref_unit_of_measure; INVERSE ADD source_offset : SET[0:?] OF coordinate_transformation FOR source_offset_unit (*<DESC>This is the transformation that specifies this unit for source offsets.*) (*<VERB>be the source unit for*); ADD target_offset : SET[0:?] OF coordinate_transformation FOR target_offset_unit (*<DESC>This is the transformation that specifies this unit for target offsets.*) (*<VERB>be the target unit for*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Add the capability of specifying a short name for the axis.*) ALTER ENTITY coordinate_system_axis; ADD abbreviation : ndt_short_name (*<DESC>This is a short name which is commonly used for this axis. These are generally names such as "x", "y", "X", "Y", "N", "E", "Lat", "Long", etc. This may or may not be an abbreviation of the property kind.*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Drop Ref_coord_trfrm_constraint because it is no longer relevant. The constraints that it was attempting to define have now been modeled explicitly.*) DROP ENTITY ref_coord_trfrm_constraint; ALTER ENTITY coordinate_transformation; INVERSE DROP ref_coord_trfrm_constraint; END_ENTITY; ALTER ENTITY ref_coordinate_sys_constraint; INVERSE DROP source_constraint; DROP target_constraint; END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Move attributes reverse_transform_valid and sign_reversal from the transformation to the method.*) ALTER ENTITY coordinate_transformation; DROP reverse_transform_valid (*<CHANGE>Moved to transformation_method.*); DROP sign_reversal (*<CHANGE>Moved to transformation_method.*); WHERE DROP val; END_ENTITY; ALTER ENTITY coordinate_trfrm_method; ADD reverse_transform_valid : ndt_boolean (*<DESC>TRUE indicates that the reverse transform is valid using the same parameters. FALSE indicates that the reverse transform is not valid.*); ADD sign_reversal : OPTIONAL ndt_boolean (*<DESC>TRUE indicates that the sign of the transformation parameter values must be reversed in order to perform a reverse transformation. FALSE indicates that the sign of the transformation parameter values must not be reversed in order to perform a reverse transformation.*); WHERE ADD val: ((reverse_transform_valid = FALSE) AND (NOT EXISTS(sign_reversal))) OR ((reverse_transform_valid = TRUE) AND EXISTS(sign_reversal)) (*<DESC>SIGN REVERSAL must be specified if REVERSE TRANSFORMATION VALID is true and cannot be specified if REVERSE TRANSFORMATION VALID is false.*) (*<RULETYPE>val*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Make some attributes mandatory.*) ALTER ENTITY geodetic_datum; ALTER prime_meridian DROP OPTIONAL; END_ENTITY; ALTER ENTITY ellipsoid; ALTER semimajor_axis DROP OPTIONAL; WHERE ALTER val : (EXISTS(semiminor_axis) XOR EXISTS(inverse_flattening)) (*<DESC>At least one of INVERSE FLATTENING or SEMIMINOR AXIS must be given but not both.*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Drop attribute effective_date from prime_meridian.*) ALTER ENTITY prime_meridian; DROP effective_date; END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Add an attribute to coordinate_trfrm_param_usage to define the "external" sort order.*) ALTER ENTITY coordinate_trfrm_param_usage; ADD sort_order : OPTIONAL ndt_int4 (*<DESC>This is the order in which this parameter is commonly listed in a list of parameters for the method.*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Drop the new relationship from transform value to prime meridian. This is no longer needed since the prime meridian is now on the geodetic datum. Add an angle value so that DMS data can be explicitly captured without a conversion. Drop the location value. This is no longer needed since the prime meridian is now on the geodetic datum and there is a relationship to Vertex.*) ALTER ENTITY coordinate_trfrm_value; DROP prime_meridian_value; DROP location_value; ADD angle_value : OPTIONAL ndt_earth_angle (*<DESC>The numerical value of the transformation parameter when it is an angle. This supports values specified as a combination of degrees, minutes and seconds (i.e., the units are assumed) and it also supports angles specified as a real value plus a unit of measure.*); ALTER quantity_value (*<DESC>The numerical value of the transformation parameter when it includes a real value and a unit of measure.*); WHERE ALTER val1 : EXISTS(integer_value) XOR (EXISTS(quantity_value) XOR (EXISTS(vertex_value) XOR (EXISTS(angle_value) XOR (EXISTS(real_value) XOR EXISTS(string_value))))) (*<DESC>Each COORDINATE TRANSFORMATION VALUE must be instantiated with any one of INTEGER VALUE, QUANTITY VALUE, REAL VALUE, VERTEX VALUE, ANGLE VALUE or STRING VALUE.*); END_ENTITY; ALTER ENTITY prime_meridian; INVERSE DROP coordinate_trfrm_value; END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>The goal of this set of changes is to simplify the model by only having one set of source/target relationships from transformation to coordinate system. This will also allow us to use the EPSG term of "single" for the leaf entity and will imply that both single and concatenated transforms are "geodetic" in nature. It will also allow the uniqueness of geodetic transformations to apply across both single and concatenated systems by putting the uniqueness clause on the supertype. Add identifier to the uniqueness rule of geodetic_transformation. This is so that "variant" transformations can exist for each coordinate system pair.*) ALTER ENTITY single_transformation DROP ABSTRACT ADD SUBTYPE OF (geodetic_transformation) DROP SUBTYPE OF (coordinate_transformation) (*<POPULATION>open*); ALTER coordinate_trfrm_method AS transformation_method; INVERSE DROP coordinate_trfrm_value (*<CHANGE>Moved to supertype.*); ADD transformation_path : SET [0:?] OF transformation_path FOR single_transformation (*<DESC>These are the concatenated transformations which utilize this transformation.*) (*<VERB>be utilized by*); WHERE ADD sri : SIZEOF(QUERY ( ctv <* parameter_value | ctv.parameter_usage.transformation_method :<>: SELF.transformation_method )) = 0 (*<DESC>The method used must be the same method which is represented by the each parameter value.*) (*<RULETYPE>sri*); END_ENTITY; ALTER ENTITY geodetic_transformation ADD ABSTRACT DROP SUBTYPE OF (single_transformation) ADD SUBTYPE OF (coordinate_transformation) (*<DESC>This is the supertype of all transformations between two coordinate systems.*) (*<POPULATION>*); INVERSE DROP transformation_path (*<CHANGE>Moved to single_transformation.*); UNIQUE ALTER si ADD identifier FIRST; END_ENTITY; ALTER ENTITY map_projection DROP SUBTYPE OF (single_transformation) ADD SUBTYPE OF (coordinate_transformation); ADD transformation_method : transformation_method (*<DESC>This is the method used to define the coordinate transformation. The method describes the parameters to be used and the manner in which they are used. *) (*<VERB>be defined by*); WHERE ADD sri : SIZEOF(QUERY ( ctv <* parameter_value | ctv.parameter_usage.transformation_method :<>: SELF.transformation_method )) = 0 (*<DESC>The method used must be the same method which is represented by the each parameter value.*) (*<RULETYPE>sri*); END_ENTITY; ALTER ENTITY concatenated_transformation DROP SUBTYPE OF (coordinate_transformation) ADD SUBTYPE OF (geodetic_transformation) (*<DESC>A concatenated transformation is accomplished by applying an ordered set of single transformations. The source system must be the source system in the first transformation and the target system must be the target system in the final transformation.*); DROP source_coordinate_system (*<CHANGE>This will now be inherited.*); DROP target_coordinate_system (*<CHANGE>This will now be inherited.*); UNIQUE DROP si (*<CHANGE>This will now be inherited.*); WHERE ADD val2 : NOT EXISTS(SELF.transformation_method) (*<DESC>A concatenated transformation cannot have a method.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY coordinate_trfrm_value; ALTER single_transformation AS transformation ALTER TYPE AS coordinate_transformation; WHERE DROP sri (*<CHANGE>Moved to transformation subtypes because Express does not allow a reference to an attribute in a subtype.*); END_ENTITY; ALTER ENTITY coordinate_trfrm_method; INVERSE ADD map_projection : SET [0:?] OF map_projection FOR transformation_method (*<DESC>These are the map projections that use this method.*) (*<VERB>be used by*); ALTER single_transformation ALTER FOR AS transformation_method (*<DESC>These are the single transformations that use this method.*); END_ENTITY; ALTER ENTITY coordinate_transformation_path (*<DESC>This association asserts that a single transformation is utilized by a concatenated transformation.*); ALTER geodetic_transformation AS single_transformation ALTER TYPE AS single_transformation (*<DESC>This is the single transformation which is part of the concatenated transformation.*); ALTER concatenated_transformation (*<DESC>This is the concatenated transformation which is composed of the single transformation.*); ALTER apply_order (*<DESC>This is the order of application of the single transformation within the context of the concatenated transformation.*); END_ENTITY; ALTER ENTITY coordinate_system; INVERSE DROP target_for_concatenated; DROP source_for_concatenated; END_ENTITY; ALTER ENTITY coordinate_transformation; INVERSE ADD parameter_value : SET [0:?] OF transformation_parameter_value FOR transformation (*<DESC>These are the values of the transformation parameters that are defined for the transformation method that defines this coordinate transformation.*) (*<VERB>have*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Drop ref_coordinate_transformation since it does not add much and it is not supported by the EPSG.*) DROP ENTITY ref_coordinate_transformation; ALTER ENTITY coordinate_trfrm_method; DROP ref_coordinate_transformation; END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>Combine local and nonspatial coordinate systems into a general CS. Drop Local_datum in favor of a relationship to Spatial_object since a local datum is the "use" of something which is spatially described.*) DROP ENTITY local_datum; DROP ENTITY nonspatial_coordinate_system; ALTER ENTITY local_coordinate_system AS general_coordinate_system (*<DESC>Any coordinate system that is not geodetically referenced as part of its fundamental definition. This can be a nonspatial coordinate system or a spatial coordinate system that is not referenced to the Earth except through a reference to an object which is has been geodetically located (i.e., we use the objects geometry as a datum or origin). A system (e.g., a vertical seismic time system) may also be related to the Earth via transform to a coordinate system that is referenced to the Earth. A local spatial system is commonly transformed to a projected system using a 2D affine transformation which involves change of origin, orientation and a differential scale change. General coordinate systems may be 1D, 2D, 3D or nD. A nonspatial system is not descriptive of spatial dimensions, such as a PVT (pressure-volume-temperature) system.*); ALTER local_datum AS spatial_reference ALTER TYPE AS spatial_object (*<DESC>Indicates the usage of a spatial object as the reference origin or (local, engineering, etc) datum for the coordinate system. For example, a vertex representation of a kelly bushing used as the origin of a measured depth system or a face representation of a geologic feature used as the datum of an isopach system.*) (*<VERB>have as a spatial reference*); ADD origin_location : OPTIONAL ndt_location (*<DESC>This is the location of the origin of the coordinate system when the location does not represent a known object.*); WHERE ADD val2 : NOT( EXISTS(spatial_reference) AND EXISTS(spatial_reference) ) (*<DESC>Each coordinate system may be instantiated with either of SPATIAL REFERENCE or ORIGIN LOCATION but not both.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY topological_object; INVERSE ALTER local_coordinate_system AS coordinate_system_context (*<DESC>These are the coordinate systems which have been defined in the context of this object. For example, a measured depth system defined for a wellbore.*); END_ENTITY; ALTER ENTITY ref_display_orientation; INVERSE ALTER local_coordinate_system AS general_coordinate_system; END_ENTITY; ALTER ENTITY vertex; INVERSE DROP local_vertical_datum; END_ENTITY; ALTER ENTITY spatial_object; INVERSE ADD coordinate_system_reference : SET[0:?] OF general_coordinate_system FOR spatial_reference (*<DESC>These are the coordinate systems which have used this object as a reference origin or (local, engineering, etc) datum for the coordinate system. For example, a measurd depth system which uses the vertex representation of a kelly bushing used as the origin.*) (*<VERB>have as a spatial reference*); END_ENTITY; ------------------------------------------------------------------------------- (*<CHANGE>The goal of this set of changes is to allow a compound coordinate system to be composed of any simple coordinate system and to be identified by those systems. An indirect result of this is that constraints on the compound system can be modeled rather than having to use rules (i.e., no axes and no transformations).*) ALTER ENTITY compound_coordinate_system DROP SUBTYPE OF (geodetic_coordinate_system) ADD SUBTYPE OF (coordinate_system) (*<DESC>This is a combination of two coordinate systems which form a third coordinate system. A typical example is a 'geographic 2d' or a 'projected 2d' horizontal coordinate system, extended to become a 3d system by any gravity related or local vertical coordinate system (e.g. depths w.r.t. instantaneous sea level). Another example is a 'local 2d' coordinate system, extended by a gravity related vertical component. An example of the latter would be a seismic bin grid system combined with Mean Sea Level referenced depths. The order of the values in a coordinate tuple will be the values that represent the axes of the first system followed by the values that represent the axes in the second system. This should not be used to create an aggregate of similar systems, such as two horizontal 2D systems or a horizontal 2D system plus a 3D system which includes a horizontal component.*); DROP geographic_system; DROP local_system; ALTER projected_system AS first_system ALTER TYPE AS simple_coordinate_system DROP OPTIONAL (*<DESC>This is the first coordinate system in the compound system. For well formed geodetic systems this will normally be a horizontal 2D system.*) (*<VERB>have as first system*); ALTER vertical_system AS second_system ALTER TYPE AS simple_coordinate_system DROP OPTIONAL (*<DESC>This is the second coordinate system in the compound system. For well formed geodetic systems this will normally be a vertical 1D system.*) (*<VERB>have as second system*); UNIQUE ADD si: first_system, second_system; WHERE DROP ose; DROP val2; ALTER val : SIZEOF ( QUERY ( cnstrtype <* ref_coordinate_sys_constraint.axis_type | (SIZEOF ( QUERY ( firstaxis <* first_system.coordinate_system_axis | (SIZEOF ( QUERY ( quan <* cnstrtype.axis_type.quantity_property | quan.property_kind :=: firstaxis.property_kind ) ) = 1) AND (firstaxis.axis_order = cnstrtype.axis_order) ) ) + SIZEOF ( QUERY ( secondaxis <* second_system.coordinate_system_axis | (SIZEOF ( QUERY ( quan <* cnstrtype.axis_type.quantity_property | quan.property_kind :=: secondaxis.property_kind ) ) = 1) AND (secondaxis.axis_order = (cnstrtype.axis_order - SIZEOF(first_system.coordinate_system_axis))) ) ) = 1) ) ) = SIZEOF (ref_coordinate_sys_constraint.axis_type) (*<DESC>The Property_kind instance specified by each component Coordinate_system_axis must be in the set allowed by the specified instance of Ref_coordinate_system_constraint and the number and order of the axes must match the constraint.*) (*<RULETYPE>val*); ALTER val1 : (NOT (SIZEOF(QUERY( typ <* TYPEOF(first_system) | typ LIKE '*GEODETIC_COORDINATE_SYSTEM*'))>0) OR NOT (SIZEOF(QUERY( typ <* TYPEOF(second_system) | typ LIKE '*GEODETIC_COORDINATE_SYSTEM*'))>0)) OR (( (SIZEOF(QUERY( typ <* TYPEOF(first_system) | typ LIKE '*VERTICAL_COORDINATE_SYSTEM*'))>0) OR (SIZEOF(QUERY( typ <* TYPEOF(second_system) | typ LIKE '*GVERTICAL_COORDINATE_SYSTEM*'))>0)) AND (( (SIZEOF(QUERY( typ <* TYPEOF(first_system) | typ LIKE '*PROJECTED_2D_COORDINATE_SYSTEM*'))>0) OR (SIZEOF(QUERY( typ <* TYPEOF(second_system) | typ LIKE '*PROJECTED_2D_COORDINATE_SYSTEM*'))>0)) OR ( (SIZEOF(QUERY( typ <* TYPEOF(first_system) | typ LIKE '*GEOGRAPHIC_2D_COORD_SYSTEM*'))>0) OR (SIZEOF(QUERY( typ <* TYPEOF(second_system) | typ LIKE '*GEOGRAPHIC_2D_COORD_SYSTEM*'))>0)))) (*<DESC>If both systems are geodetic then one must be vertical and one must be 2D.*); END_ENTITY; ADD ENTITY simple_coordinate_system ABSTRACT SUPERTYPE OF (ONEOF(local_coordinate_system, geodetic_coordinate_system)) SUBTYPE OF (coordinate_system) (*<DESC>This is the abstract supertype of all non-compound coordinate systems.*); INVERSE coordinate_system_axis : SET [0:?] OF coordinate_system_axis FOR coordinate_system (*<DESC>These are coordinate system axes that make up this coordinate system. An axis may not be used more than once in a coordinate system.*) (*<VERB>be defined by*); source_for_geodetic : SET [0:?] OF geodetic_transformation FOR source_coordinate_system (*<DESC>This describes the set of transformations that utilize this coordinate system as a source.*) (*<VERB>be the basis of one*); target_for_geodetic : SET [0:?] OF geodetic_transformation FOR target_coordinate_system (*<DESC>This describes the set of transformations that utilize this coordinate system as a target.*) (*<VERB>be a target for*); compound_first_component : SET [0:?] OF compound_coordinate_system FOR first_system (*<DESC>This is the set of compound systems which utilize this system as the first component in the compound system.*) (*<VERB>be utilized first in*); compound_second_component : SET [0:?] OF compound_coordinate_system FOR second_system (*<DESC>This is the set of compound systems which utilize this system as the second component in the compound system.*) (*<VERB>be utilized second in*); WHERE val: SIZEOF ( QUERY ( cnstrtype <* ref_coordinate_sys_constraint.axis_type | SIZEOF ( QUERY ( axis <* coordinate_system_axis | (SIZEOF ( QUERY ( quan <* cnstrtype.axis_type.quantity_property | quan.property_kind :=: axis.property_kind ) ) = 1) AND (axis.axis_order = cnstrtype.axis_order) ) ) = 1 ) ) = SIZEOF (coordinate_system_axis) (*<CHANGE>Moved from supertype. Make it a useful rule.*) (*<DESC>The Property_kind instance specified by each Coordinate_system_axis must be in the set allowed by the specified instance of Ref_coordinate_system_constraint.*) (*<RULETYPE>val*); END_ENTITY; ALTER ENTITY local_coordinate_system DROP SUBTYPE OF (coordinate_system); INVERSE DROP compound_system (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY geodetic_coordinate_system DROP SUBTYPE OF (coordinate_system); END_ENTITY; ALTER ENTITY vertical_coordinate_system (*<DESC>A vertical earth-referenced height or depth coordinate system which is based on a well known geodetic vertical datum. Local heights or depths should use subtype General Coordinate System.*); INVERSE DROP compound_system (*<CHANGE>Moved to supertype.*); WHERE DROP val (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY geographic_2d_coord_system; INVERSE DROP compound_system (*<CHANGE>Moved to supertype.*); WHERE DROP val (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY projected_2d_coordinate_system; INVERSE DROP compound_system (*<CHANGE>Moved to supertype.*); WHERE DROP val (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY geocentric_coordinate_system; WHERE DROP val (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY geographic_3d_coord_system; WHERE DROP val (*<CHANGE>Moved to supertype.*); END_ENTITY; ALTER ENTITY coordinate_system; INVERSE DROP coordinate_system_axis (*<CHANGE>Moved to subtype.*); DROP source_for_geodetic (*<CHANGE>Moved to subtype.*); DROP target_for_geodetic (*<CHANGE>Moved to subtype.*); WHERE DROP val (*<CHANGE>Moved equivalent to subtype.*); DROP sri (*<CHANGE>Move to subtype because the axis moved.*); END_ENTITY; ALTER ENTITY coordinate_system_axis; ALTER coordinate_system ALTER TYPE AS simple_coordinate_system; END_ENTITY; ALTER ENTITY geodetic_transformation; ALTER source_coordinate_system ALTER TYPE AS simple_coordinate_system; ALTER target_coordinate_system ALTER TYPE AS simple_coordinate_system; END_ENTITY; END_CHANGE;