sbt-scalaxb.opengis.gml.geometryPrimitives.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of geotrellis-server-opengis_2.12 Show documentation
GeoTrellis Server is a set of components designed to simplify viewing, processing, and serving raster data from arbitrary sources with an emphasis on doing so in a functional style.
The newest version!
// Generated by scalaxb.
package opengis.gml


/** 
			GML is an OGC Standard.
			Copyright (c) 2001,2005,2010 Open Geospatial Consortium.
			To obtain additional rights of use, visit http://www.opengeospatial.org/legal/ .
		
*/


/** Curve is a 1-dimensional primitive. Curves are continuous, connected, and have a measurable length in terms of the coordinate system. 
				A curve is composed of one or more curve segments. Each curve segment within a curve may be defined using a different interpolation method. The curve segments are connected to one another, with the end point of each segment except the last being the start point of the next segment in the segment list.
				The orientation of the curve is positive.
*/
case class CurveType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  segments: opengis.gml.CurveSegmentArrayPropertyType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveType {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


/** OrientableCurve consists of a curve and an orientation. If the orientation is "+", then the OrientableCurve is identical to the baseCurve. If the orientation is "-", then the OrientableCurve is related to another _Curve with a parameterization that reverses the sense of the curve traversal.
*/
case class OrientableCurveType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  baseCurve: opengis.gml.CurvePropertyType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveType {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
  lazy val orientation = attributes("@orientation").as[SignType]
}

      
      


/** Curve segment defines a homogeneous segment of a curve.
*/
trait AbstractCurveSegmentType {
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
}


/** A container for an array of curve segments.
*/
case class CurveSegmentArrayPropertyType(_CurveSegment: Seq[scalaxb.DataRecord[Any]] = Nil)
      
      


/** A LineStringSegment is a curve segment that is defined by two or more coordinate tuples, with linear interpolation between them.
				Note: LineStringSegment implements GM_LineString of ISO 19107.
*/
case class LineStringSegmentType(linestringsegmenttypeoption: Seq[scalaxb.DataRecord[opengis.gml.LineStringSegmentTypeOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveSegmentType {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
}

      
      

trait LineStringSegmentTypeOption2 extends LineStringSegmentTypeOption
trait LineStringSegmentTypeOption

/** An ArcString is a curve segment that uses three-point circular arc interpolation.
*/
trait ArcStringTypable extends AbstractCurveSegmentType {
  def arcstringtypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringTypableOption]]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
  def numArc: Option[BigInt]
}


/** An ArcString is a curve segment that uses three-point circular arc interpolation.
*/
case class ArcStringType(arcstringtypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringTypableOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcStringTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes.get("@numArc") map { _.as[BigInt]}
}

      
      

trait ArcStringTypableOption2 extends ArcStringTypableOption
trait ArcStringTypableOption

/** An Arc is an arc string with only one arc unit, i.e. three control points.
*/
trait ArcTypable extends ArcStringTypable {
  def arcstringtypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringTypableOption]]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
  def numArc: Option[BigInt]
}


/** An Arc is an arc string with only one arc unit, i.e. three control points.
*/
case class ArcType(arcstringtypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringTypableOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes.get("@numArc") map { _.as[BigInt]}
}

      
      

trait ArcTypableOption2 extends ArcTypableOption
trait ArcTypableOption

/** A Circle is an arc whose ends coincide to form a simple closed loop. The "start" and "end" bearing are equal and shall be the bearing for the first controlPoint listed. The three control points must be distinct non-co-linear points for the Circle to be unambiguously defined. The arc is simply extended past the third control point until the first control point is encountered.
*/
case class CircleType(arcstringtypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringTypableOption]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes.get("@numArc") map { _.as[BigInt]}
}

      
      


/** This variant of the arc computes the mid points of the arcs instead of storing the coordinates directly. The control point sequence consists of the start and end points of each arc plus the bulge.
*/
trait ArcStringByBulgeTypable extends AbstractCurveSegmentType {
  def arcstringbybulgetypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringByBulgeTypableOption]]
  def bulge: Seq[Double]
  def normal: Seq[opengis.gml.VectorType]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
  def numArc: Option[BigInt]
}


/** This variant of the arc computes the mid points of the arcs instead of storing the coordinates directly. The control point sequence consists of the start and end points of each arc plus the bulge.
*/
case class ArcStringByBulgeType(arcstringbybulgetypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringByBulgeTypableOption]] = Nil,
  bulge: Seq[Double] = Nil,
  normal: Seq[opengis.gml.VectorType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcStringByBulgeTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes.get("@numArc") map { _.as[BigInt]}
}

      
      

trait ArcStringByBulgeTypableOption2 extends ArcStringByBulgeTypableOption
trait ArcStringByBulgeTypableOption

/** An ArcByBulge is an arc string with only one arc unit, i.e. two control points and one bulge.
*/
case class ArcByBulgeType(arcstringbybulgetypableoption: Seq[scalaxb.DataRecord[opengis.gml.ArcStringByBulgeTypableOption]] = Nil,
  bulge: Seq[Double] = Nil,
  normal: Seq[opengis.gml.VectorType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcStringByBulgeTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes.get("@numArc") map { _.as[BigInt]}
}

      
      

trait ArcByBulgeTypeOption2 extends ArcByBulgeTypeOption
trait ArcByBulgeTypeOption

/** This variant of the arc requires that the points on the arc have to be computed instead of storing the coordinates directly. The control point is the center point of the arc plus the radius and the bearing at start and end. This represenation can be used only in 2D.
*/
trait ArcByCenterPointTypable extends AbstractCurveSegmentType {
  def arcbycenterpointtypableoption: scalaxb.DataRecord[opengis.gml.ArcByCenterPointTypableOption]
  def radius: opengis.gml.LengthType
  def startAngle: Option[opengis.gml.AngleType]
  def endAngle: Option[opengis.gml.AngleType]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
  def numArc: BigInt
}


/** This variant of the arc requires that the points on the arc have to be computed instead of storing the coordinates directly. The control point is the center point of the arc plus the radius and the bearing at start and end. This represenation can be used only in 2D.
*/
case class ArcByCenterPointType(arcbycenterpointtypableoption: scalaxb.DataRecord[opengis.gml.ArcByCenterPointTypableOption],
  radius: opengis.gml.LengthType,
  startAngle: Option[opengis.gml.AngleType] = None,
  endAngle: Option[opengis.gml.AngleType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcByCenterPointTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes("@numArc").as[BigInt]
}

      
      

trait ArcByCenterPointTypableOption2 extends ArcByCenterPointTypableOption
trait ArcByCenterPointTypableOption

/** A CircleByCenterPoint is an ArcByCenterPoint with identical start and end angle to form a full circle. Again, this represenation can be used only in 2D.
*/
case class CircleByCenterPointType(arcbycenterpointtypableoption: scalaxb.DataRecord[opengis.gml.ArcByCenterPointTypableOption],
  radius: opengis.gml.LengthType,
  startAngle: Option[opengis.gml.AngleType] = None,
  endAngle: Option[opengis.gml.AngleType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ArcByCenterPointTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val numArc = attributes("@numArc").as[BigInt]
}

      
      


/** An offset curve is a curve at a constant
		 distance from the basis curve. They can be useful as a cheap
		 and simple alternative to constructing curves that are offsets	
		 by definition.
*/
case class OffsetCurveType(offsetBase: opengis.gml.CurvePropertyType,
  distance: opengis.gml.LengthType,
  refDirection: Option[opengis.gml.VectorType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveSegmentType {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
}

      
      


/** A placement takes a standard geometric
   construction and places it in geographic space. It defines a
   transformation from a constructive parameter space to the 
   co-ordinate space of the co-ordinate reference system being used.  
   Parameter spaces in formulae in this International Standard are 
   given as (u, v) in 2D and(u, v, w) in 3D. Co-ordinate reference 
   systems positions are given in formulae, in this International 
   Standard, by either (x, y) in 2D, or (x, y, z) in 3D.

   Affine placements are defined by linear transformations from 
   parameter space to the target co-ordiante space. 2-dimensional 
   Cartesian parameter space,(u,v) transforms into 3-dimensional co-
   ordinate reference systems,(x,y,z) by using an affine 
   transformation,(u,v)->(x,y,z) which is defined :

	x	ux vx  	x0
			 u	  
	y =	uy vy   + y0
			 v		
	x	uz vz	z0
	
   Then, given this equation, the location element of the 
   AffinePlacement is the direct position (x0, y0, z0), which is the
   target position of the origin in (u, v). The two reference
   directions (ux, uy, uz) and (vx, vy, vz) are the target     
   directions of the unit vectors at the origin in (u, v).
*/
case class AffinePlacementType(location: opengis.gml.DirectPositionType,
  refDirection: Seq[opengis.gml.VectorType] = Nil,
  inDimension: BigInt,
  outDimension: BigInt)
      
      


case class RefLocation(AffinePlacement: opengis.gml.AffinePlacementType)
      
      


/** A clothoid, or Cornu's spiral, is plane
   curve whose curvature is a fixed function of its length.
   In suitably chosen co-ordinates it is given by Fresnel's
   integrals.

    x(t) = 0-integral-t cos(AT*T/2)dT    
    
    y(t) = 0-integral-t sin(AT*T/2)dT
   
   This geometry is mainly used as a transition curve between
   curves of type straight line to circular arc or circular arc
   to circular arc. With this curve type it is possible to 
   achieve a C2-continous transition between the above mentioned
   curve types. One formula for the Clothoid is A*A = R*t where
   A is constant, R is the varying radius of curvature along the
   the curve and t is the length along and given in the Fresnel 
   integrals.
*/
case class ClothoidType(refLocation: opengis.gml.RefLocation,
  scaleFactor: BigDecimal,
  startParameter: Double,
  endParameter: Double,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveSegmentType {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
}

      
      


/** A GeodesicString consists of sequence of
   geodesic segments. The type essentially combines a sequence of
   Geodesic into a single object.
   The GeodesicString is computed from two or more positions and an
   interpolation using geodesics defined from the geoid (or 
   ellipsoid) of the co-ordinate reference system being used.
*/
trait GeodesicStringTypable extends AbstractCurveSegmentType {
  def geodesicstringtypableoption: Seq[scalaxb.DataRecord[Any]]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
}


/** A GeodesicString consists of sequence of
   geodesic segments. The type essentially combines a sequence of
   Geodesic into a single object.
   The GeodesicString is computed from two or more positions and an
   interpolation using geodesics defined from the geoid (or 
   ellipsoid) of the co-ordinate reference system being used.
*/
case class GeodesicStringType(geodesicstringtypableoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends GeodesicStringTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
}

      
      

trait GeodesicStringTypableOption

/** A Geodesic consists of two distinct
   positions joined by a geodesic curve. The control points of
   a Geodesic shall lie on the geodesic between its start
   point and end points. Between these two points, a geodesic
   curve defined from ellipsoid or geoid model used by the
   co-ordinate reference systems may be used to interpolate
   other positions. Any other point in the controlPoint array
   must fall on this geodesic.
*/
case class GeodesicType(geodesicstringtypableoption: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends GeodesicStringTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
}

      
      


/** Cubic splines are similar to line strings in that they are a sequence of segments each with its own defining function. A cubic spline uses the control points and a set of derivative parameters to define a piecewise 3rd degree polynomial interpolation. Unlike line-strings, the parameterization by arc length is not necessarily still a polynomial. 
				The function describing the curve must be C2, that is, have a continuous 1st and 2nd derivative at all points, and pass through the controlPoints in the order given. Between the control points, the curve segment is defined by a cubic polynomial. At each control point, the polynomial changes in such a manner that the 1st and 2nd derivative vectors are the same from either side. The control parameters record must contain vectorAtStart, and vectorAtEnd which are the unit tangent vectors at controlPoint[1] and controlPoint[n] where n = controlPoint.count. 
				Note: only the direction of the vectors is relevant, not their length.
*/
case class CubicSplineType(cubicsplinetypeoption: Seq[scalaxb.DataRecord[opengis.gml.CubicSplineTypeOption]] = Nil,
  vectorAtStart: opengis.gml.VectorType,
  vectorAtEnd: opengis.gml.VectorType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractCurveSegmentType {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val degree = attributes("@degree").as[BigInt]
}

      
      

trait CubicSplineTypeOption
trait CubicSplineTypeOption2 extends CubicSplineTypeOption

/** A knot is a breakpoint on a piecewise spline curve.
*/
case class KnotType(value: Double,
  multiplicity: BigInt,
  weight: Double)
      
      


/** Encapsulates a knot to use it in a geometric type.
*/
case class KnotPropertyType(Knot: opengis.gml.KnotType)
      
      


/** A B-Spline is a piecewise parametric polynomial or rational curve described in terms of control points and basis functions. Knots are breakpoints on the curve that connect its pieces. They are given as a non-decreasing sequence of real numbers. If the weights in the knots are equal then it is a polynomial spline. The degree is the algebraic degree of the basis functions.
*/
trait BSplineTypable extends AbstractCurveSegmentType {
  def bsplinetypableoption: Seq[scalaxb.DataRecord[opengis.gml.BSplineTypableOption]]
  def degree: BigInt
  def knot: Seq[opengis.gml.KnotPropertyType]
  def numDerivativesAtStart: BigInt
  def numDerivativesAtEnd: BigInt
  def numDerivativeInterior: BigInt
  def interpolation: opengis.gml.CurveInterpolationType
  def isPolynomial: Option[Boolean]
  def knotType: Option[opengis.gml.KnotTypesType]
}


/** A B-Spline is a piecewise parametric polynomial or rational curve described in terms of control points and basis functions. Knots are breakpoints on the curve that connect its pieces. They are given as a non-decreasing sequence of real numbers. If the weights in the knots are equal then it is a polynomial spline. The degree is the algebraic degree of the basis functions.
*/
case class BSplineType(bsplinetypableoption: Seq[scalaxb.DataRecord[opengis.gml.BSplineTypableOption]] = Nil,
  degree: BigInt,
  knot: Seq[opengis.gml.KnotPropertyType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BSplineTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val isPolynomial = attributes.get("@isPolynomial") map { _.as[Boolean]}
  lazy val knotType = attributes.get("@knotType") map { _.as[KnotTypesType]}
}

      
      

trait BSplineTypableOption2 extends BSplineTypableOption
trait BSplineTypableOption

/** Bezier curves are polynomial splines that use Bezier or Bernstein polynomials for interpolation purposes. It is a special case of the B-Spline curve with two knots.
*/
case class BezierType(bsplinetypableoption: Seq[scalaxb.DataRecord[opengis.gml.BSplineTypableOption]] = Nil,
  degree: BigInt,
  knot: Seq[opengis.gml.KnotPropertyType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends BSplineTypable {
  lazy val numDerivativesAtStart = attributes("@numDerivativesAtStart").as[BigInt]
  lazy val numDerivativesAtEnd = attributes("@numDerivativesAtEnd").as[BigInt]
  lazy val numDerivativeInterior = attributes("@numDerivativeInterior").as[BigInt]
  lazy val interpolation = attributes("@interpolation").as[CurveInterpolationType]
  lazy val isPolynomial = attributes.get("@isPolynomial") map { _.as[Boolean]}
  lazy val knotType = attributes.get("@knotType") map { _.as[KnotTypesType]}
}

      
      

trait BezierTypeOption
trait BezierTypeOption2 extends BezierTypeOption

/** A Surface is a 2-dimensional primitive and is composed of one or more surface patches. The surface patches are connected to one another.
				The orientation of the surface is positive ("up"). The orientation of a surface chooses an "up" direction through the choice of the upward normal, which, if the surface is not a cycle, is the side of the surface from which the exterior boundary appears counterclockwise. Reversal of the surface orientation reverses the curve orientation of each boundary component, and interchanges the conceptual "up" and "down" direction of the surface. If the surface is the boundary of a solid, the "up" direction is usually outward. For closed surfaces, which have no boundary, the up direction is that of the surface patches, which must be consistent with one another. Its included surface patches describe the interior structure of the Surface.
*/
trait SurfaceTypable extends AbstractSurfaceTypable {
  def standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence
  def patches: scalaxb.DataRecord[Any]
  def gmlid: Option[String]
  def gid: Option[String]
  def srsName: Option[java.net.URI]
  def srsDimension: Option[BigInt]
  def axisLabels: Option[Seq[String]]
  def uomLabels: Option[Seq[String]]
}


/** A Surface is a 2-dimensional primitive and is composed of one or more surface patches. The surface patches are connected to one another.
				The orientation of the surface is positive ("up"). The orientation of a surface chooses an "up" direction through the choice of the upward normal, which, if the surface is not a cycle, is the side of the surface from which the exterior boundary appears counterclockwise. Reversal of the surface orientation reverses the curve orientation of each boundary component, and interchanges the conceptual "up" and "down" direction of the surface. If the surface is the boundary of a solid, the "up" direction is usually outward. For closed surfaces, which have no boundary, the up direction is that of the surface patches, which must be consistent with one another. Its included surface patches describe the interior structure of the Surface.
*/
case class SurfaceType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  patches: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SurfaceTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


/** OrientableSurface consists of a surface and an orientation. If the orientation is "+", then the OrientableSurface is identical to the baseSurface. If the orientation is "-", then the OrientableSurface is a reference to a Surface with an up-normal that reverses the direction for this OrientableSurface, the sense of "the top of the surface".
*/
case class OrientableSurfaceType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  baseSurface: opengis.gml.SurfacePropertyType,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSurfaceTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
  lazy val orientation = attributes("@orientation").as[SignType]
}

      
      


/** A surface patch defines a homogenuous portion of a surface.
*/
trait AbstractSurfacePatchType {
  
}


/** A container for an array of surface patches.
*/
trait SurfacePatchArrayPropertyTypable {
  def surfacepatcharraypropertytypablesequence1: Seq[opengis.gml.SurfacePatchArrayPropertyTypableSequence1]
}


/** A container for an array of surface patches.
*/
case class SurfacePatchArrayPropertyType(surfacepatcharraypropertytypablesequence1: Seq[opengis.gml.SurfacePatchArrayPropertyTypableSequence1] = Nil) extends SurfacePatchArrayPropertyTypable
      
      

case class SurfacePatchArrayPropertyTypableSequence1(_SurfacePatch: scalaxb.DataRecord[Any])
      


/** A PolygonPatch is a surface patch that is defined by a set of boundary curves and an underlying surface to which these curves adhere. The curves are coplanar and the polygon uses planar interpolation in its interior. Implements GM_Polygon of ISO 19107.
*/
case class PolygonPatchType(exterior: Option[scalaxb.DataRecord[Any]] = None,
  interior: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSurfacePatchType {
  lazy val interpolation = attributes("@interpolation").as[SurfaceInterpolationType]
}

      
      


/** Represents a triangle as a surface with an outer boundary consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries. The number of points in the linear ring must be four.
*/
case class TriangleType(exterior: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSurfacePatchType {
  lazy val interpolation = attributes("@interpolation").as[SurfaceInterpolationType]
}

      
      


/** Represents a rectangle as a surface with an outer boundary consisting of a linear ring. Note that this is a polygon (subtype) with no inner boundaries. The number of points in the linear ring must be five.
*/
case class RectangleType(exterior: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSurfacePatchType {
  lazy val interpolation = attributes("@interpolation").as[SurfaceInterpolationType]
}

      
      


/** A Ring is used to represent a single connected component of a surface boundary. It consists of a sequence of curves connected in a cycle (an object whose boundary is empty).
A Ring is structurally similar to a composite curve in that the endPoint of each curve in the sequence is the startPoint of the next curve in the Sequence. Since the sequence is circular, there is no exception to this rule. Each ring, like all boundaries, is a cycle and each ring is simple.
NOTE: Even though each Ring is simple, the boundary need not be simple. The easiest case of this is where one of the interior rings of a surface is tangent to its exterior ring.
*/
case class RingType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  curveMember: Seq[opengis.gml.CurvePropertyType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractRingType {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


/** Encapsulates a ring to represent properties in features or geometry collections.
*/
case class RingPropertyType(Ring: opengis.gml.RingType)
      
      


case class Row(geometricPositionListGroupOption1: Seq[scalaxb.DataRecord[Any]] = Nil)
      
      


/** 
			
*/
trait AbstractParametricCurveSurfaceTypable extends AbstractSurfacePatchType {
  
}


/** 
			
*/
case class AbstractParametricCurveSurfaceType() extends AbstractParametricCurveSurfaceTypable
      
      


/** A gridded surface is a parametric curve
   surface derived from a rectangular grid in the parameter
   space. The rows from this grid are control points for
   horizontal surface curves; the columns are control points
   for vertical surface curves. The working assumption is that
   for a pair of parametric co-ordinates (s, t) that the
   horizontal curves for each integer offset are calculated
   and evaluated at "s". The defines a sequence of control
   points:
   
   cn(s) : s  1 .....columns 

   From this sequence a vertical curve is calculated for "s",
   and evaluated at "t". In most cases, the order of
   calculation (horizontal-vertical vs. vertical-horizontal)
   does not make a difference. Where it does, the horizontal-   
   vertical order shall be the one used.

   Logically, any pair of curve interpolation types can lead
   to a subtype of GriddedSurface. The following clauses
   define some most commonly encountered surfaces that can
   be represented in this manner.
*/
trait AbstractGriddedSurfaceTypable extends AbstractParametricCurveSurfaceTypable {
  def pointGridSequence2: opengis.gml.PointGridSequence
  def rows: Option[BigInt]
  def columns: Option[BigInt]
}


/** A gridded surface is a parametric curve
   surface derived from a rectangular grid in the parameter
   space. The rows from this grid are control points for
   horizontal surface curves; the columns are control points
   for vertical surface curves. The working assumption is that
   for a pair of parametric co-ordinates (s, t) that the
   horizontal curves for each integer offset are calculated
   and evaluated at "s". The defines a sequence of control
   points:
   
   cn(s) : s  1 .....columns 

   From this sequence a vertical curve is calculated for "s",
   and evaluated at "t". In most cases, the order of
   calculation (horizontal-vertical vs. vertical-horizontal)
   does not make a difference. Where it does, the horizontal-   
   vertical order shall be the one used.

   Logically, any pair of curve interpolation types can lead
   to a subtype of GriddedSurface. The following clauses
   define some most commonly encountered surfaces that can
   be represented in this manner.
*/
case class AbstractGriddedSurfaceType(pointGridSequence2: opengis.gml.PointGridSequence,
  rows: Option[BigInt] = None,
  columns: Option[BigInt] = None) extends AbstractGriddedSurfaceTypable
      
      


/** A cone is a gridded surface given as a
   family of conic sections whose control points vary linearly.
   NOTE! A 5-point ellipse with all defining positions identical
   is a point. Thus, a truncated elliptical cone can be given as a
   2x5 set of control points
   ((P1, P1, P1, P1, P1), (P2, P3, P4, P5, P6)). P1 is the apex 
   of the cone. P2, P3,P4, P5 and P6 are any five distinct points
   around the base ellipse of the cone. If the horizontal curves
   are circles as opposed to ellipses, the a circular cone can
   be constructed using ((P1, P1, P1),(P2, P3, P4)). The apex most     
   not coinside with the other plane.
*/
case class ConeType(pointGridSequence2: opengis.gml.PointGridSequence,
  rows: Option[BigInt] = None,
  columns: Option[BigInt] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractGriddedSurfaceTypable {
  lazy val horizontalCurveType = attributes("@horizontalCurveType").as[CurveInterpolationType]
  lazy val verticalCurveType = attributes("@verticalCurveType").as[CurveInterpolationType]
}

      
      


/** A cylinder is a gridded surface given as a
   family of circles whose positions vary along a set of parallel
   lines, keeping the cross sectional horizontal curves of a
   constant shape.
   NOTE! Given the same working assumptions as in the previous
   note, a Cylinder can be given by two circles, giving us the
   control points of the form ((P1, P2, P3),(P4, P5, P6)).
*/
case class CylinderType(pointGridSequence2: opengis.gml.PointGridSequence,
  rows: Option[BigInt] = None,
  columns: Option[BigInt] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractGriddedSurfaceTypable {
  lazy val horizontalCurveType = attributes("@horizontalCurveType").as[CurveInterpolationType]
  lazy val verticalCurveType = attributes("@verticalCurveType").as[CurveInterpolationType]
}

      
      


/** A sphere is a gridded surface given as a
   family of circles whose positions vary linearly along the
   axis of the sphere, and whise radius varies in proportions to
   the cosine function of the central angle. The horizontal 
   circles resemble lines of constant latitude, and the vertical
   arcs resemble lines of constant longitude. 
   NOTE! If the control points are sorted in terms of increasing
   longitude, and increasing latitude, the upNormal of a sphere
   is the outward normal.
   EXAMPLE If we take a gridded set of latitudes and longitudes
   in degrees,(u,v) such as

	(-90,-180)  (-90,-90)  (-90,0)  (-90,  90) (-90, 180) 
	(-45,-180)  (-45,-90)  (-45,0)  (-45,  90) (-45, 180) 
	(  0,-180)  (  0,-90)  (  0,0)  (  0,  90) (  0, 180)
	( 45,-180)  ( 45,-90)  ( 45,0)  ( 45, -90) ( 45, 180)
	( 90,-180)  ( 90,-90)  ( 90,0)  ( 90, -90) ( 90, 180)
   
   And map these points to 3D using the usual equations (where R
   is the radius of the required sphere).

    z = R sin u
    x = (R cos u)(sin v)
    y = (R cos u)(cos v)

   We have a sphere of Radius R, centred at (0,0), as a gridded
   surface. Notice that the entire first row and the entire last
   row of the control points map to a single point in each 3D
   Euclidean space, North and South poles respectively, and that
   each horizontal curve closes back on itself forming a 
   geometric cycle. This gives us a metrically bounded (of finite
   size), topologically unbounded (not having a boundary, a
   cycle) surface.
*/
case class SphereType(pointGridSequence2: opengis.gml.PointGridSequence,
  rows: Option[BigInt] = None,
  columns: Option[BigInt] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractGriddedSurfaceTypable {
  lazy val horizontalCurveType = attributes("@horizontalCurveType").as[CurveInterpolationType]
  lazy val verticalCurveType = attributes("@verticalCurveType").as[CurveInterpolationType]
}

      
      


/** A polyhedral surface is a surface composed
   of polygon surfaces connected along their common boundary 
   curves. This differs from the surface type only in the
   restriction on the types of surface patches acceptable.
*/
case class PolyhedralSurfaceType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  patches: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SurfaceTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


/** This type defines a container for an array of 
   polygon patches.
*/
case class PolygonPatchArrayPropertyType(surfacepatcharraypropertytypablesequence1: Seq[opengis.gml.SurfacePatchArrayPropertyTypableSequence1] = Nil) extends SurfacePatchArrayPropertyTypable
      
      

case class PolygonPatchArrayPropertyTypeSequence1(PolygonPatch: opengis.gml.PolygonPatchType)
      


/** This type defines a container for an array of 
     triangle patches.
*/
case class TrianglePatchArrayPropertyType(surfacepatcharraypropertytypablesequence1: Seq[opengis.gml.SurfacePatchArrayPropertyTypableSequence1] = Nil) extends SurfacePatchArrayPropertyTypable
      
      

case class TrianglePatchArrayPropertyTypeSequence1(Triangle: opengis.gml.TriangleType)
      


/** A triangulated surface is a polyhedral 
   surface that is composed only of triangles. There is no
   restriction on how the triangulation is derived.
*/
trait TriangulatedSurfaceTypable extends SurfaceTypable {
  def standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence
  def patches: scalaxb.DataRecord[Any]
  def gmlid: Option[String]
  def gid: Option[String]
  def srsName: Option[java.net.URI]
  def srsDimension: Option[BigInt]
  def axisLabels: Option[Seq[String]]
  def uomLabels: Option[Seq[String]]
}


/** A triangulated surface is a polyhedral 
   surface that is composed only of triangles. There is no
   restriction on how the triangulation is derived.
*/
case class TriangulatedSurfaceType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  patches: scalaxb.DataRecord[Any],
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TriangulatedSurfaceTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


case class ControlPoint(controlpointoption: Seq[scalaxb.DataRecord[Any]] = Nil)
      
      

trait ControlPointOption

/** A tin is a triangulated surface that uses
   the Delauny algorithm or a similar algorithm complemented with
   consideration of breaklines, stoplines, and maximum length of 
   triangle sides. These networks satisfy the Delauny's criterion
   away from the modifications: Fore each triangle in the 
   network, the circle passing through its vertices does not
   contain, in its interior, the vertex of any other triangle.
*/
case class TinType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  patches: scalaxb.DataRecord[Any],
  stopLines: Seq[opengis.gml.LineStringSegmentArrayPropertyType] = Nil,
  breakLines: Seq[opengis.gml.LineStringSegmentArrayPropertyType] = Nil,
  maxLength: opengis.gml.LengthType,
  controlPoint: opengis.gml.ControlPoint,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends TriangulatedSurfaceTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


case class LineStringSegmentArrayPropertyType(LineStringSegment: Seq[opengis.gml.LineStringSegmentType] = Nil)
      
      


/** An abstraction of a solid to support the different levels of complexity. A solid is always contiguous.
*/
trait AbstractSolidTypable extends AbstractGeometricPrimitiveType {
  def standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence
  def gmlid: Option[String]
  def gid: Option[String]
  def srsName: Option[java.net.URI]
  def srsDimension: Option[BigInt]
  def axisLabels: Option[Seq[String]]
  def uomLabels: Option[Seq[String]]
}


/** An abstraction of a solid to support the different levels of complexity. A solid is always contiguous.
*/
case class AbstractSolidType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSolidTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      


/** A property that has a solid as its value domain can either be an appropriate geometry element encapsulated in an element of this type or an XLink reference to a remote geometry element (where remote includes geometry elements located elsewhere in the same document). Either the reference or the contained element must be given, but neither both nor none.
*/
case class SolidPropertyType(solidpropertytypesequence1: Option[opengis.gml.SolidPropertyTypeSequence1] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) {
  lazy val xlinktype = attributes("@{http://www.w3.org/1999/xlink}type").as[xlink.TypeType]
  lazy val xlinkhref = attributes.get("@{http://www.w3.org/1999/xlink}href") map { _.as[java.net.URI]}
  lazy val xlinkrole = attributes.get("@{http://www.w3.org/1999/xlink}role") map { _.as[java.net.URI]}
  lazy val xlinkarcrole = attributes.get("@{http://www.w3.org/1999/xlink}arcrole") map { _.as[java.net.URI]}
  lazy val xlinktitle = attributes.get("@{http://www.w3.org/1999/xlink}title") map { _.as[String]}
  lazy val xlinkshow = attributes.get("@{http://www.w3.org/1999/xlink}show") map { _.as[xlink.ShowType]}
  lazy val xlinkactuate = attributes.get("@{http://www.w3.org/1999/xlink}actuate") map { _.as[xlink.ActuateType]}
  lazy val gmlremoteSchema = attributes.get("@{http://www.opengis.net/gml}remoteSchema") map { _.as[java.net.URI]}
}

      
      

case class SolidPropertyTypeSequence1(_Solid: scalaxb.DataRecord[Any])
      


/** A container for an array of solids. The elements are always contained in the array property, referencing geometry elements or arrays of geometry elements is not supported.
*/
case class SolidArrayPropertyType(solidarraypropertytypesequence1: Seq[opengis.gml.SolidArrayPropertyTypeSequence1] = Nil)
      
      

case class SolidArrayPropertyTypeSequence1(_Solid: scalaxb.DataRecord[Any])
      


/** A solid is the basis for 3-dimensional geometry. The extent of a solid is defined by the boundary surfaces (shells). A shell is represented by a composite surface, where every  shell is used to represent a single connected component of the boundary of a solid. It consists of a composite surface (a list of orientable surfaces) connected in a topological cycle (an object whose boundary is empty). Unlike a Ring, a Shell's elements have no natural sort order. Like Rings, Shells are simple.
*/
case class SolidType(standardObjectPropertiesSequence1: opengis.gml.StandardObjectPropertiesSequence,
  exterior: Option[opengis.gml.SurfacePropertyType] = None,
  interior: Seq[opengis.gml.SurfacePropertyType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends AbstractSolidTypable {
  lazy val gmlid = attributes.get("@{http://www.opengis.net/gml}id") map { _.as[String]}
  lazy val gid = attributes.get("@gid") map { _.as[String]}
  lazy val srsName = attributes.get("@srsName") map { _.as[java.net.URI]}
  lazy val srsDimension = attributes.get("@srsDimension") map { _.as[BigInt]}
  lazy val axisLabels = attributes.get("@axisLabels") map { _.as[Seq[String]]}
  lazy val uomLabels = attributes.get("@uomLabels") map { _.as[Seq[String]]}
}

      
      

sealed trait CurveInterpolationType

object CurveInterpolationType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.gml.CurveInterpolationType]): CurveInterpolationType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: CurveInterpolationType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[CurveInterpolationType] = Seq(LinearValue, Geodesic, CircularArc3Points, CircularArc2PointWithBulge, CircularArcCenterPointWithRadius, Elliptical, Clothoid, Conic, PolynomialSpline, CubicSpline, RationalSpline)
}

case object LinearValue extends CurveInterpolationType { override def toString = "linear" }
case object Geodesic extends CurveInterpolationType { override def toString = "geodesic" }
case object CircularArc3Points extends CurveInterpolationType { override def toString = "circularArc3Points" }
case object CircularArc2PointWithBulge extends CurveInterpolationType { override def toString = "circularArc2PointWithBulge" }
case object CircularArcCenterPointWithRadius extends CurveInterpolationType { override def toString = "circularArcCenterPointWithRadius" }
case object Elliptical extends CurveInterpolationType { override def toString = "elliptical" }
case object Clothoid extends CurveInterpolationType { override def toString = "clothoid" }
case object Conic extends CurveInterpolationType { override def toString = "conic" }
case object PolynomialSpline extends CurveInterpolationType { override def toString = "polynomialSpline" }
case object CubicSpline extends CurveInterpolationType { override def toString = "cubicSpline" }
case object RationalSpline extends CurveInterpolationType { override def toString = "rationalSpline" }

sealed trait SurfaceInterpolationType

object SurfaceInterpolationType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.gml.SurfaceInterpolationType]): SurfaceInterpolationType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: SurfaceInterpolationType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[SurfaceInterpolationType] = Seq(NoneType, Planar, Spherical, EllipticalValue, ConicValue, Tin, ParametricCurve, PolynomialSplineValue, RationalSplineValue, TriangulatedSpline)
}

case object NoneType extends SurfaceInterpolationType { override def toString = "none" }
case object Planar extends SurfaceInterpolationType { override def toString = "planar" }
case object Spherical extends SurfaceInterpolationType { override def toString = "spherical" }
case object EllipticalValue extends SurfaceInterpolationType { override def toString = "elliptical" }
case object ConicValue extends SurfaceInterpolationType { override def toString = "conic" }
case object Tin extends SurfaceInterpolationType { override def toString = "tin" }
case object ParametricCurve extends SurfaceInterpolationType { override def toString = "parametricCurve" }
case object PolynomialSplineValue extends SurfaceInterpolationType { override def toString = "polynomialSpline" }
case object RationalSplineValue extends SurfaceInterpolationType { override def toString = "rationalSpline" }
case object TriangulatedSpline extends SurfaceInterpolationType { override def toString = "triangulatedSpline" }

sealed trait KnotTypesType

object KnotTypesType {
  def fromString(value: String, scope: scala.xml.NamespaceBinding)(implicit fmt: scalaxb.XMLFormat[opengis.gml.KnotTypesType]): KnotTypesType = fmt.reads(scala.xml.Text(value), Nil) match {
    case Right(x: KnotTypesType) => x
    case x => throw new RuntimeException(s"fromString returned unexpected value $x for input $value")
  }
  lazy val values: Seq[KnotTypesType] = Seq(Uniform, QuasiUniform, PiecewiseBezier)
}

case object Uniform extends KnotTypesType { override def toString = "uniform" }
case object QuasiUniform extends KnotTypesType { override def toString = "quasiUniform" }
case object PiecewiseBezier extends KnotTypesType { override def toString = "piecewiseBezier" }

case class PointGridSequence(row: opengis.gml.Row*)