rgeo 2.3.1 → 3.0.1

data/lib/rgeo/coord_sys/cs/entities.rb

@@ -134,12 +134,19 @@ module RGeo
       # Highest possible value for local datum types.
       LD_MAX = 32_767
 
+      # Flags indicating parts of domain covered by a convex hull. These flags can be combined. For
+      # example, the value 3 corresponds to a combination of CT_DF_Inside and MF_DF_Outside, which
+      # means that some parts of the convex hull are inside the domain, and some parts of the convex
+      # hull are outside the domain
+      CT_DF_INSIDE = 1
+      CT_DF_OUTSIDE = 2
+      CT_DF_DISCONTINUOUS = 4
+
       # This is a base class for all OGC coordinate system objects.
       # This includes both interfaces and data types from the OGC
       # Coordinate Transformation spec.
       #
       # This is a non-instantiable abstract class.
-
       class Base
         # Standard object inspection output
 
@@ -150,8 +157,8 @@ module RGeo
         # Tests for equality. Two objects are defined as equal if they
         # have the same type (class) and the same WKT representation.
 
-        def eql?(rhs)
-          rhs.class == self.class && rhs.to_wkt == to_wkt
+        def eql?(other)
+          other.class == self.class && other.to_wkt == to_wkt
         end
         alias == eql?
 
@@ -172,19 +179,21 @@ module RGeo
         # <tt>:standard_brackets</tt>
         #   If true, outputs parentheses rather than square
         #   brackets. Default is false.
-        def to_wkt(standard_brackets = false)
+        def to_wkt(standard_brackets: false)
           open, close = brackets(standard_brackets)
           content = wkt_content(standard_brackets).map { |obj| ",#{obj}" }.join
-          if defined?(@authority) && @authority
-            authority = ",AUTHORITY#{open}#{@authority.inspect},#{@authority_code.inspect}#{close}"
-          else
-            authority = ""
-          end
-          if defined?(@extensions) && @extensions
-            extensions = @extensions.map { |k, v| ",EXTENSION#{open}#{k.inspect},#{v.inspect}#{close}" }.join
-          else
-            extensions = ""
-          end
+          authority =
+            if defined?(@authority) && @authority
+              ",AUTHORITY#{open}#{@authority.inspect},#{@authority_code.inspect}#{close}"
+            else
+              ""
+            end
+          extensions =
+            if defined?(@extensions) && @extensions
+              @extensions.map { |k, v| ",EXTENSION#{open}#{k.inspect},#{v.inspect}#{close}" }.join
+            else
+              ""
+            end
           "#{wkt_typename}#{open}#{@name.inspect}#{content}#{extensions}#{authority}#{close}"
         end
 
@@ -197,12 +206,11 @@ module RGeo
         def marshal_load(data) # :nodoc:
           data = data["wkt"] if data.is_a?(Hash)
           temp = CS.create_from_wkt(data)
-          if temp.class == self.class
-            temp.instance_variables.each do |iv|
-              instance_variable_set(iv, temp.instance_variable_get(iv))
-            end
-          else
-            raise TypeError, "Bad Marshal data"
+
+          raise TypeError, "Bad Marshal data" unless temp.instance_of?(self.class)
+
+          temp.instance_variables.each do |iv|
+            instance_variable_set(iv, temp.instance_variable_get(iv))
           end
         end
 
@@ -214,12 +222,11 @@ module RGeo
 
         def init_with(coder) # :nodoc:
           temp = CS.create_from_wkt(coder.type == :scalar ? coder.scalar : coder["wkt"])
-          if temp.class == self.class
-            temp.instance_variables.each do |iv|
-              instance_variable_set(iv, temp.instance_variable_get(iv))
-            end
-          else
-            raise TypeError, "Bad YAML data"
+
+          raise TypeError, "Bad YAML data" unless temp.instance_of?(self.class)
+
+          temp.instance_variables.each do |iv|
+            instance_variable_set(iv, temp.instance_variable_get(iv))
           end
         end
 
@@ -238,20 +245,21 @@ module RGeo
       #
       # Details of axis. This is used to label axes, and indicate the
       # orientation.
-
       class AxisInfo < Base
         # :stopdoc:
         NAMES_BY_VALUE = %w[OTHER NORTH SOUTH EAST WEST UP DOWN].freeze
         # :startdoc:
 
         def initialize(name, orientation) # :nodoc:
+          super()
           @name = name
-          case orientation
-          when String, Symbol
-            @orientation = NAMES_BY_VALUE.index(orientation.to_s.upcase).to_i
-          else
-            @orientation = orientation.to_i
-          end
+          @orientation =
+            case orientation
+            when String, Symbol
+              NAMES_BY_VALUE.index(orientation.to_s.upcase).to_i
+            else
+              orientation.to_i
+            end
         end
 
         # Human readable name for axis. Possible values are "X", "Y",
@@ -293,9 +301,9 @@ module RGeo
       # projected coordinate system. The angular units of parameter
       # values match the angular units of the geographic coordinate
       # system that the projected coordinate system is based on.
-
       class ProjectionParameter < Base
         def initialize(name, value) # :nodoc:
+          super()
           @name = name
           @value = value.to_f
         end
@@ -331,15 +339,15 @@ module RGeo
       # Wolf parameters should be applied to geocentric coordinates, where
       # the X axis points towards the Greenwich Prime Meridian, the Y axis
       # points East, and the Z axis points North.
-
       class WGS84ConversionInfo < Base
-        def initialize(dx, dy, dz, ex, ey, ez, ppm) # :nodoc:
-          @dx = dx.to_f
-          @dy = dy.to_f
-          @dz = dz.to_f
-          @ex = ex.to_f
-          @ey = ey.to_f
-          @ez = ez.to_f
+        def initialize(dx_meters, dy_meters, dz_meters, ex_arc_seconds, ey_arc_seconds, ez_arc_seconds, ppm) # :nodoc:
+          super()
+          @dx = dx_meters.to_f
+          @dy = dy_meters.to_f
+          @dz = dz_meters.to_f
+          @ex = ex_arc_seconds.to_f
+          @ey = ey_arc_seconds.to_f
+          @ez = ez_arc_seconds.to_f
           @ppm = ppm.to_f
         end
 
@@ -364,7 +372,7 @@ module RGeo
         # Bursa Wolf scaling in in parts per million.
         attr_reader :ppm
 
-        def to_wkt(standard_brackets = false)
+        def to_wkt(standard_brackets: false)
           open, close = brackets(standard_brackets)
           "TOWGS84#{open}#{@dx},#{@dy},#{@dz},#{@ex},#{@ey},#{@ez},#{@ppm}#{close}"
         end
@@ -375,8 +383,8 @@ module RGeo
           # The Bursa Wolf shift should be in meters, the rotation in arc
           # seconds, and the scaling in parts per million.
 
-          def create(dx, dy, dz, ex, ey, ez, ppm)
-            new(dx, dy, dz, ex, ey, ez, ppm)
+          def create(dx_meters, dy_meters, dz_meters, ex_arc_seconds, ey_arc_seconds, ez_arc_seconds, ppm)
+            new(dx_meters, dy_meters, dz_meters, ex_arc_seconds, ey_arc_seconds, ez_arc_seconds, ppm)
           end
         end
       end
@@ -419,9 +427,10 @@ module RGeo
       # * <b>alias</b>: an alias
       # * <b>remarks</b>: provider-supplied remarks.
       # * <b>extensions</b>: a hash of extension keys and values
-
       class Info < Base
-        def initialize(name, authority = nil, authority_code = nil, abbreviation = nil, init_alias = nil, remarks = nil, extensions = nil) # :nodoc:
+        def initialize(name, authority = nil, authority_code = nil, abbreviation = nil, init_alias = nil,
+                       remarks = nil, extensions = nil) # :nodoc:
+          super()
           @name = name
           @authority = authority ? authority.to_s : nil
           @authority_code = authority_code ? authority_code.to_s : nil
@@ -480,7 +489,6 @@ module RGeo
       # Normally, you will instantiate one of the subclasses LinearUnit or
       # AngularUnit. However, it is possible to instantiate Unit if it is
       # not clear whether the data refers to a LinearUnit or AngularUnit.
-
       class Unit < Info
         def initialize(name, conversion_factor, *optional) # :nodoc:
           super(name, *optional)
@@ -517,7 +525,6 @@ module RGeo
       # == OGC spec description
       #
       # Definition of linear units.
-
       class LinearUnit < Unit
         # Returns the number of meters per LinearUnit.
         # Also available as Unit#conversion_factor.
@@ -540,7 +547,6 @@ module RGeo
       # == OGC spec description
       #
       # Definition of angular units.
-
       class AngularUnit < Unit
         # Returns the number of radians per AngularUnit.
         # Also available as Unit#conversion_factor.
@@ -563,7 +569,6 @@ module RGeo
       # == OGC spec description
       #
       # A meridian used to take longitude measurements from.
-
       class PrimeMeridian < Info
         def initialize(name, angular_unit, longitude, *optional) # :nodoc:
           super(name, *optional)
@@ -603,9 +608,9 @@ module RGeo
       # == OGC spec description
       #
       # An approximation of the Earth's surface as a squashed sphere.
-
       class Ellipsoid < Info
-        def initialize(name, semi_major_axis, semi_minor_axis, inverse_flattening, ivf_definitive, linear_unit, *optional) # :nodoc:
+        def initialize(name, semi_major_axis, semi_minor_axis, inverse_flattening, ivf_definitive,
+                       linear_unit, *optional) # :nodoc:
           super(name, *optional)
           @semi_major_axis = semi_major_axis.to_f
           @semi_minor_axis = semi_minor_axis.to_f
@@ -710,7 +715,6 @@ module RGeo
       # This is a non-instantiable abstract class. You must instantiate
       # one of the subclasses HorizontalDatum, VerticalDatum, or
       # LocalDatum.
-
       class Datum < Info
         def initialize(name, datum_type, *optional) # :nodoc:
           super(name, *optional)
@@ -730,7 +734,6 @@ module RGeo
       # == OGC spec description
       #
       # Procedure used to measure vertical distances.
-
       class VerticalDatum < Datum
         def wkt_typename
           "VERT_DATUM"
@@ -760,7 +763,6 @@ module RGeo
       # coordinates can be transformed between two different local
       # coordinate systems, as long as they are based on the same local
       # datum.
-
       class LocalDatum < Datum
         def wkt_typename
           "LOCAL_DATUM"
@@ -786,7 +788,6 @@ module RGeo
       # == OGC spec description
       #
       # Procedure used to measure positions on the surface of the Earth.
-
       class HorizontalDatum < Datum
         def initialize(name, datum_type, ellipsoid, wgs84_parameters, *optional) # :nodoc:
           super(name, datum_type, *optional)
@@ -820,8 +821,8 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          array = [@ellipsoid.to_wkt(standard_brackets)]
-          array << @wgs84_parameters.to_wkt(standard_brackets) if @wgs84_parameters
+          array = [@ellipsoid.to_wkt(standard_brackets: standard_brackets)]
+          array << @wgs84_parameters.to_wkt(standard_brackets: standard_brackets) if @wgs84_parameters
           array
         end
       end
@@ -829,7 +830,6 @@ module RGeo
       # == OGC spec description
       #
       # A projection from geographic coordinates to projected coordinates.
-
       class Projection < Info
         def initialize(name, class_name, parameters, *optional) # :nodoc:
           super(name, *optional)
@@ -908,7 +908,6 @@ module RGeo
       # GeographicCoordinateSystem, ProjectedCoordinateSystem,
       # VerticalCoordinateSystem, LocalCoordinateSystem, or
       # CompoundCoordinateSystem.
-
       class CoordinateSystem < Info
         def initialize(name, dimension, *optional) # :nodoc:
           super(name, *optional)
@@ -921,16 +920,61 @@ module RGeo
         # Gets axis details for dimension within coordinate system. Each
         # dimension in the coordinate system has a corresponding axis.
 
-        def get_axis(dimension)
+        def get_axis(_dimension)
           nil
         end
 
         # Gets units for dimension within coordinate system. Each
         # dimension in the coordinate system has corresponding units.
 
-        def get_units(dimension)
+        def get_units(_dimension)
           nil
         end
+
+        def geographic?
+          false
+        end
+
+        def projected?
+          false
+        end
+
+        def wkt_typename
+          "CS"
+        end
+
+        # Not an OGC method, but useful for being able to
+        # transform directly from a CoordinateSystem object.
+        def transform_coords(target_cs, x, y, z = nil)
+          ct = CoordinateTransform.create(self, target_cs)
+          ct.transform_coords(x, y, z)
+        end
+
+        class << self
+          def create(defn, dimension = 2, *optional)
+            # Need this so we can maintain consistency with actual
+            # CoordinateSystem implementations
+
+            if defn.is_a?(Integer)
+              # not technically correct but we can use cartesian as a placeholder
+              # to form valid wkt
+              defn_string = "Cartesian"
+              new(defn_string, dimension, "EPSG", defn, *optional)
+            else
+              new(defn, dimension, *optional)
+            end
+          end
+
+          def create_from_wkt(str)
+            CS.create_from_wkt(str)
+          end
+        end
+
+        private
+
+        def wkt_content(_)
+          [@dimension]
+        end
       end
 
       # == OGC spec description
@@ -940,7 +984,6 @@ module RGeo
       # as a geographic or a projected coordinate system with a horizontal
       # datum. The other is a vertical CRS which is a one-dimensional
       # coordinate system with a vertical datum.
-
       class CompoundCoordinateSystem < CoordinateSystem
         def initialize(name, head, tail, *optional) # :nodoc:
           super(name, head.dimension + tail.dimension, *optional)
@@ -985,7 +1028,7 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          [@head.to_wkt(standard_brackets), @tail.to_wkt(standard_brackets)]
+          [@head.to_wkt(standard_brackets: standard_brackets), @tail.to_wkt(standard_brackets: standard_brackets)]
         end
       end
 
@@ -1007,7 +1050,6 @@ module RGeo
       #
       # RGeo's implementation does not provide the Coordinate
       # Transformation (CT) package.
-
       class LocalCoordinateSystem < CoordinateSystem
         def initialize(name, local_datum, unit, axes, *optional) # :nodoc:
           super(name, axes.size, *optional)
@@ -1027,7 +1069,7 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index)
+        def get_units(_index)
           @unit
         end
 
@@ -1050,9 +1092,9 @@ module RGeo
 
         def wkt_content(standard_brackets)
           [
-            @local_datum.to_wkt(standard_brackets),
-            @unit.to_wkt(standard_brackets)
-          ] + @axes.map { |ax| ax.to_wkt(standard_brackets) }
+            @local_datum.to_wkt(standard_brackets: standard_brackets),
+            @unit.to_wkt(standard_brackets: standard_brackets)
+          ] + @axes.map { |ax| ax.to_wkt(standard_brackets: standard_brackets) }
         end
       end
 
@@ -1064,7 +1106,6 @@ module RGeo
       # the Z axis will point North, and the Y axis will point East (e.g.
       # a right handed system), but you should check the axes for
       # non-default values.
-
       class GeocentricCoordinateSystem < CoordinateSystem
         def initialize(name, horizontal_datum, prime_meridian, linear_unit, axis0, axis1, axis2, *optional) # :nodoc:
           super(name, 3, *optional)
@@ -1090,7 +1131,7 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index)
+        def get_units(_index)
           @linear_unit
         end
 
@@ -1100,6 +1141,10 @@ module RGeo
           [@axis0, @axis1, @axis2][index]
         end
 
+        def geographic?
+          true
+        end
+
         def wkt_typename
           "GEOCCS"
         end
@@ -1120,13 +1165,13 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @horizontal_datum.to_wkt(standard_brackets),
-            @prime_meridian.to_wkt(standard_brackets),
-            @linear_unit.to_wkt(standard_brackets)
+            @horizontal_datum.to_wkt(standard_brackets: standard_brackets),
+            @prime_meridian.to_wkt(standard_brackets: standard_brackets),
+            @linear_unit.to_wkt(standard_brackets: standard_brackets)
           ]
-          arr << @axis0.to_wkt(standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets) if @axis1
-          arr << @axis2.to_wkt(standard_brackets) if @axis2
+          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
+          arr << @axis2.to_wkt(standard_brackets: standard_brackets) if @axis2
           arr
         end
       end
@@ -1135,7 +1180,6 @@ module RGeo
       #
       # A one-dimensional coordinate system suitable for vertical
       # measurements.
-
       class VerticalCoordinateSystem < CoordinateSystem
         def initialize(name, vertical_datum, vertical_unit, axis, *optional) # :nodoc:
           super(name, 1, *optional)
@@ -1153,13 +1197,13 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index)
+        def get_units(_index)
           @vertical_unit
         end
 
         # Implements CoordinateSystem#get_axis
 
-        def get_axis(index)
+        def get_axis(_index)
           @axis
         end
 
@@ -1181,8 +1225,11 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          arr = [@vertical_datum.to_wkt(standard_brackets), @vertical_unit.to_wkt(standard_brackets)]
-          arr << @axis.to_wkt(standard_brackets) if @axis
+          arr = [
+            @vertical_datum.to_wkt(standard_brackets: standard_brackets),
+            @vertical_unit.to_wkt(standard_brackets: standard_brackets)
+          ]
+          arr << @axis.to_wkt(standard_brackets: standard_brackets) if @axis
           arr
         end
       end
@@ -1196,7 +1243,6 @@ module RGeo
       # This is a non-instantiable abstract class. You must instantiate
       # one of the subclasses GeographicCoordinateSystem or
       # ProjectedCoordinateSystem.
-
       class HorizontalCoordinateSystem < CoordinateSystem
         def initialize(name, horizontal_datum, *optional) # :nodoc:
           super(name, 2, *optional)
@@ -1214,7 +1260,6 @@ module RGeo
       # You can find out which this is by examining the axes. You should
       # also check the angular units, since not all geographic coordinate
       # systems use degrees.
-
       class GeographicCoordinateSystem < HorizontalCoordinateSystem
         def initialize(name, angular_unit, horizontal_datum, prime_meridian, axis0, axis1, *optional) # :nodoc:
           super(name, horizontal_datum, *optional)
@@ -1233,7 +1278,7 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index)
+        def get_units(_index)
           @angular_unit
         end
 
@@ -1255,10 +1300,14 @@ module RGeo
         # of interest. The first conversion (with index=0) should provide
         # acceptable accuracy over the largest possible area of interest.
 
-        def get_wgs84_conversion_info(index)
+        def get_wgs84_conversion_info(_index)
           @horizontal_datum.wgs84_parameters
         end
 
+        def geographic?
+          true
+        end
+
         def wkt_typename
           "GEOGCS"
         end
@@ -1279,12 +1328,12 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @horizontal_datum.to_wkt(standard_brackets),
-            @prime_meridian.to_wkt(standard_brackets),
-            @angular_unit.to_wkt(standard_brackets)
+            @horizontal_datum.to_wkt(standard_brackets: standard_brackets),
+            @prime_meridian.to_wkt(standard_brackets: standard_brackets),
+            @angular_unit.to_wkt(standard_brackets: standard_brackets)
           ]
-          arr << @axis0.to_wkt(standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets) if @axis1
+          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
           arr
         end
       end
@@ -1292,7 +1341,6 @@ module RGeo
       # == OGC spec description
       #
       # A 2D cartographic coordinate system.
-
       class ProjectedCoordinateSystem < HorizontalCoordinateSystem
         def initialize(name, geographic_coordinate_system, projection, linear_unit, axis0, axis1, *optional) # :nodoc:
           super(name, geographic_coordinate_system.horizontal_datum, *optional)
@@ -1315,7 +1363,7 @@ module RGeo
 
         # Implements CoordinateSystem#get_units
 
-        def get_units(index)
+        def get_units(_index)
           @linear_unit
         end
 
@@ -1325,6 +1373,10 @@ module RGeo
           index == 1 ? @axis1 : @axis0
         end
 
+        def projected?
+          true
+        end
+
         def wkt_typename
           "PROJCS"
         end
@@ -1344,14 +1396,166 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          arr = [@geographic_coordinate_system.to_wkt(standard_brackets), @projection.to_wkt(standard_brackets)]
-          @projection.each_parameter { |param| arr << param.to_wkt(standard_brackets) }
-          arr << @linear_unit.to_wkt(standard_brackets)
-          arr << @axis0.to_wkt(standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets) if @axis1
+          arr = [
+            @geographic_coordinate_system.to_wkt(standard_brackets: standard_brackets),
+            @projection.to_wkt(standard_brackets: standard_brackets)
+          ]
+          @projection.each_parameter { |param| arr << param.to_wkt(standard_brackets: standard_brackets) }
+          arr << @linear_unit.to_wkt(standard_brackets: standard_brackets)
+          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
+          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
           arr
         end
       end
+
+      # CoordinateTransform object. Note it is a combo of
+      # CoordinateTransform and MathTransform as specified in
+      # the OGC standard. This is just to simplify the model
+      # and keep all functionality in this class.
+      #
+      # @see https://portal.ogc.org/files/?artifact_id=999 page 79
+      class CoordinateTransform < Info
+        # Initialize a new CoordinateTransform
+        #
+        # Note this class should not be used directly since it does not
+        # implement any transformation logic. It merely defines
+        # what methods actual implementations must use.
+        #
+        # @param [CoordinateSystem] source_cs
+        # @param [CoordinateSystem] target_cs
+        # @param [Array] optional any params for Info or Base
+        # @return [CoordinateTransform]
+        def initialize(source_cs, target_cs, *optional)
+          super(optional)
+          @source_cs = source_cs
+          @target_cs = target_cs
+        end
+        attr_accessor :source_cs, :target_cs
+
+        # TODO: This changes depending on what type of conversion is done
+        # and we can't know unless we implement the conversion ourselves.
+        # We should delegate all of the wkt generation to the library
+        # if possible.
+        def wkt_typename
+          "CONVERSION"
+        end
+
+        def inspect
+          "#<#{self.class}:0x#{object_id.to_s(16)} @source_cs=#{source_cs.to_wkt} @target_cs=#{target_cs.to_wkt}>"
+        end
+
+        # Human readable description of domain in source coordinate system.
+        #
+        # @return [String]
+        def area_of_use
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Semantic type of transform. For example, a datum transformation or a coordinate conversion.
+        #
+        # @return [String]
+        def transform_type
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Dimension of the source_cs
+        #
+        # @return [Integer]
+        def dim_source
+          source_cs.dimension
+        end
+
+        # Dimension of the target_cs
+        #
+        # @return [Integer]
+        def dim_target
+          target_cs.dimension
+        end
+
+        # Tests whether this transform does not move any points
+        #
+        # @return [Boolean]
+        def identity?
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Gets flags classifying domain points within a convex hull. The supplied ordinates are interpreted
+        # as a sequence of points, which generates a convex hull in the source space. Conceptually, each
+        # of the (usually infinite) points inside the convex hull is then tested against the source domain.
+        # The flags of all these tests are then combined. In practice, implementations of different
+        # transforms will use different short-cuts to avoid doing an infinite number of tests.
+        #
+        # @param [Array<<Array<Integer>>] points in tuples of (x,y,z) with z being optional
+        # @return [Array<Integer>] the domain_flags of the input points
+        def domain_flags(points)
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Gets transformed convex hull. The supplied ordinates are interpreted as a sequence of points,
+        # which generates a convex hull in the source space. The returned sequence of ordinates
+        # represents a convex hull in the output space. The number of output points will often be different
+        # from the number of input points. Each of the input points should be inside the valid domain (this
+        # can be checked by testing the points' domain flags individually). However, the convex hull of the
+        # input points may go outside the valid domain. The returned convex hull should contain the
+        # transformed image of the intersection of the source convex hull and the source domain.
+        #
+        # @param [Array<<Array<Integer>>] points in tuples of (x,y,z) with z being optional
+        # @return [Array<<Array<Integer>>]
+        def codomain_convex_hull(points)
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Transforms a coordinate point. The passed parameter point should not be modified.
+        #
+        # @param [Integer] x
+        # @param [Integer] y
+        # @param [Integer] z optional
+        # @return [Array<Integer>] transformed point coordinates in (x,y,z) order
+        def transform_coords(x, y, z = nil)
+          raise NotImplementedError, "#{__method__} is not implemented in the abstract CoordinateTransform class."
+        end
+
+        # Transforms a coordinate point. The passed parameter point should not be modified.
+        #
+        # @param [Array<Array<Integer>>] points in (x,y,z) tuples where z is optional
+        # @return [Array<Array<Integer>>] list of transformed point coordinates in (x,y,z) order
+        def transform_list(points)
+          points.map { |x, y, z| transform_coords(x, y, z) }
+        end
+
+        # Creates the inverse transform of this object. This method may fail if the transform is not one to
+        # one. However, all cartographic projections should succeed.
+        #
+        # @return [CoordinateTransform]
+        def inverse
+          self.class.create(target_cs, source_cs)
+        end
+
+        class << self
+          # Initialize a new CoordinateTransform
+          #
+          # Note this class should not be used directly since it does not
+          # implement any transformation logic. It merely defines
+          # what methods actual implementations must use.
+          #
+          # @param [CoordinateSystem] source_cs
+          # @param [CoordinateSystem] target_cs
+          # @param [Array] optional any params for Info or Base
+          # @return [CoordinateTransform]
+          def create(source_cs, target_cs, *optional)
+            new(source_cs, target_cs, optional)
+          end
+        end
+
+        private
+
+        def wkt_content(standard_brackets)
+          source_cs_wkt = "SOURCECS[#{source_cs.to_wkt(standard_brackets: standard_brackets)}]"
+          target_cs_wkt = "TARGETCS[#{target_cs.to_wkt(standard_brackets: standard_brackets)}]"
+
+          [source_cs_wkt, target_cs_wkt]
+        end
+      end
     end
   end
 end