All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • sbt-scalaxb.opengis.se.Symbolizer.scala Maven / Gradle / Ivy

    Go to download

    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.se


/** 
      SE Symbolizer version 1.1.0 (2010-02-01)
      
      Symbology Encoding is an OGC Standard.
      Copyright (c) 2005,2010 Open Geospatial Consortium.
      To obtain additional rights of use, visit http://www.opengeospatial.org/legal/ .
		
*/


/** 
        A "SymbolizerType" is an abstract type for encoding the graphical
        properties used to portray geographic information.  Concrete Symbolizer
        types are derived from this base type.
      
*/
trait SymbolizerType {
  def Name: Option[String]
  def Description: Option[opengis.se.DescriptionType]
  def BaseSymbolizer: Option[opengis.se.BaseSymbolizerType]
  def version: Option[opengis.se.VersionType]
  def uom: Option[java.net.URI]
}


case class BaseSymbolizerType(OnlineResource: opengis.se.OnlineResourceType)
      
      


case class LineSymbolizerType(Name: Option[String] = None,
  Description: Option[opengis.se.DescriptionType] = None,
  BaseSymbolizer: Option[opengis.se.BaseSymbolizerType] = None,
  Geometry: Option[opengis.se.GeometryType] = None,
  Stroke: Option[opengis.se.StrokeType] = None,
  PerpendicularOffset: Option[opengis.se.ParameterValueTypable] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SymbolizerType with ImageOutlineTypeOption {
  lazy val version = attributes.get("@version") map { _.as[VersionType]}
  lazy val uom = attributes.get("@uom") map { _.as[java.net.URI]}
}

      
      


case class GeometryType(PropertyName: opengis.ogc.PropertyNameType)
      
      


case class StrokeType(stroketypeoption: Option[scalaxb.DataRecord[opengis.se.StrokeTypeOption]] = None,
  SvgParameter: Seq[opengis.se.SvgParameterType] = Nil)
      
      

trait StrokeTypeOption

case class SvgParameterType(mixed: Seq[scalaxb.DataRecord[Any]] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends ParameterValueTypable {
  lazy val name = attributes("@name").as[String]
}

      
      


/** 
        The "ParameterValueType" uses WFS-Filter expressions to give
        values for SE graphic parameters.  A "mixed" element-content
        model is used with textual substitution for values.
      
*/
trait ParameterValueTypable {
  
}


/** 
        The "ParameterValueType" uses WFS-Filter expressions to give
        values for SE graphic parameters.  A "mixed" element-content
        model is used with textual substitution for values.
      
*/
case class ParameterValueType(mixed: Seq[scalaxb.DataRecord[Any]] = Nil) extends ParameterValueTypable
      
      

case class ParameterValueTypableSequence1(expression: scalaxb.DataRecord[Any])
      


case class GraphicFillType(Graphic: opengis.se.GraphicType) extends StrokeTypeOption
      
      


case class GraphicStrokeType(Graphic: opengis.se.GraphicType,
  InitialGap: Option[opengis.se.ParameterValueTypable] = None,
  Gap: Option[opengis.se.ParameterValueTypable] = None) extends StrokeTypeOption
      
      


case class PolygonSymbolizerType(Name: Option[String] = None,
  Description: Option[opengis.se.DescriptionType] = None,
  BaseSymbolizer: Option[opengis.se.BaseSymbolizerType] = None,
  Geometry: Option[opengis.se.GeometryType] = None,
  Fill: Option[opengis.se.FillType] = None,
  Stroke: Option[opengis.se.StrokeType] = None,
  Displacement: Option[opengis.se.DisplacementType] = None,
  PerpendicularOffset: Option[opengis.se.ParameterValueTypable] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SymbolizerType with ImageOutlineTypeOption {
  lazy val version = attributes.get("@version") map { _.as[VersionType]}
  lazy val uom = attributes.get("@uom") map { _.as[java.net.URI]}
}

      
      


case class FillType(GraphicFill: Option[opengis.se.GraphicFillType] = None,
  SvgParameter: Seq[opengis.se.SvgParameterType] = Nil)
      
      


case class PointSymbolizerType(Name: Option[String] = None,
  Description: Option[opengis.se.DescriptionType] = None,
  BaseSymbolizer: Option[opengis.se.BaseSymbolizerType] = None,
  Geometry: Option[opengis.se.GeometryType] = None,
  Graphic: Option[opengis.se.GraphicType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SymbolizerType {
  lazy val version = attributes.get("@version") map { _.as[VersionType]}
  lazy val uom = attributes.get("@uom") map { _.as[java.net.URI]}
}

      
      


case class GraphicType(graphictypeoption: Seq[scalaxb.DataRecord[opengis.se.GraphicTypeOption]] = Nil,
  Opacity: Option[opengis.se.ParameterValueTypable] = None,
  Size: Option[opengis.se.ParameterValueTypable] = None,
  Rotation: Option[opengis.se.ParameterValueTypable] = None,
  AnchorPoint: Option[opengis.se.AnchorPointType] = None,
  Displacement: Option[opengis.se.DisplacementType] = None)
      
      

trait GraphicTypeOption

case class ExternalGraphicType(externalgraphictypeoption: scalaxb.DataRecord[opengis.se.ExternalGraphicTypeOption],
  Format: String,
  ColorReplacement: Seq[opengis.se.ColorReplacementType] = Nil) extends GraphicTypeOption
      
      

trait ExternalGraphicTypeOption

case class ColorReplacementType(Recode: opengis.se.RecodeType)
      
      


case class MarkType(marktypeoption: Option[scalaxb.DataRecord[Any]] = None,
  Fill: Option[opengis.se.FillType] = None,
  Stroke: Option[opengis.se.StrokeType] = None) extends GraphicTypeOption
      
      

case class MarkTypeSequence1(marktypeoption2: scalaxb.DataRecord[opengis.se.MarkTypeOption2],
  Format: String,
  MarkIndex: Option[BigInt] = None)
      

trait MarkTypeOption2
trait MarkTypeOption

case class TextSymbolizerType(Name: Option[String] = None,
  Description: Option[opengis.se.DescriptionType] = None,
  BaseSymbolizer: Option[opengis.se.BaseSymbolizerType] = None,
  Geometry: Option[opengis.se.GeometryType] = None,
  Label: Option[opengis.se.ParameterValueTypable] = None,
  Font: Option[opengis.se.FontType] = None,
  LabelPlacement: Option[opengis.se.LabelPlacementType] = None,
  Halo: Option[opengis.se.HaloType] = None,
  Fill: Option[opengis.se.FillType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SymbolizerType {
  lazy val version = attributes.get("@version") map { _.as[VersionType]}
  lazy val uom = attributes.get("@uom") map { _.as[java.net.URI]}
}

      
      


case class FontType(SvgParameter: Seq[opengis.se.SvgParameterType] = Nil)
      
      


case class LabelPlacementType(labelplacementtypeoption: scalaxb.DataRecord[opengis.se.LabelPlacementTypeOption])
      
      

trait LabelPlacementTypeOption

case class PointPlacementType(AnchorPoint: Option[opengis.se.AnchorPointType] = None,
  Displacement: Option[opengis.se.DisplacementType] = None,
  Rotation: Option[opengis.se.ParameterValueTypable] = None) extends LabelPlacementTypeOption
      
      


case class AnchorPointType(AnchorPointX: opengis.se.ParameterValueTypable,
  AnchorPointY: opengis.se.ParameterValueTypable)
      
      


case class DisplacementType(DisplacementX: opengis.se.ParameterValueTypable,
  DisplacementY: opengis.se.ParameterValueTypable)
      
      


case class LinePlacementType(PerpendicularOffset: Option[opengis.se.ParameterValueTypable] = None,
  IsRepeated: Option[Boolean] = None,
  InitialGap: Option[opengis.se.ParameterValueTypable] = None,
  Gap: Option[opengis.se.ParameterValueTypable] = None,
  IsAligned: Option[Boolean] = None,
  GeneralizeLine: Option[Boolean] = None) extends LabelPlacementTypeOption
      
      


case class HaloType(Radius: Option[opengis.se.ParameterValueTypable] = None,
  Fill: Option[opengis.se.FillType] = None)
      
      


case class RasterSymbolizerType(Name: Option[String] = None,
  Description: Option[opengis.se.DescriptionType] = None,
  BaseSymbolizer: Option[opengis.se.BaseSymbolizerType] = None,
  Geometry: Option[opengis.se.GeometryType] = None,
  Opacity: Option[opengis.se.ParameterValueTypable] = None,
  ChannelSelection: Option[opengis.se.ChannelSelectionType] = None,
  OverlapBehavior: Option[opengis.se.OverlapBehavior] = None,
  ColorMap: Option[opengis.se.ColorMapType] = None,
  ContrastEnhancement: Option[opengis.se.ContrastEnhancementType] = None,
  ShadedRelief: Option[opengis.se.ShadedReliefType] = None,
  ImageOutline: Option[opengis.se.ImageOutlineType] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends SymbolizerType {
  lazy val version = attributes.get("@version") map { _.as[VersionType]}
  lazy val uom = attributes.get("@uom") map { _.as[java.net.URI]}
}

      
      


case class ChannelSelectionType(channelselectiontypeoption: scalaxb.DataRecord[opengis.se.ChannelSelectionTypeOption])
      
      

trait ChannelSelectionTypeOption
case class ChannelSelectionTypeSequence1(RedChannel: opengis.se.SelectedChannelType,
  GreenChannel: opengis.se.SelectedChannelType,
  BlueChannel: opengis.se.SelectedChannelType) extends ChannelSelectionTypeOption
      


case class SelectedChannelType(SourceChannelName: String,
  ContrastEnhancement: Option[opengis.se.ContrastEnhancementType] = None) extends ChannelSelectionTypeOption
      
      

sealed trait OverlapBehavior

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

case object LATEST_ON_TOP extends OverlapBehavior { override def toString = "LATEST_ON_TOP" }
case object EARLIEST_ON_TOP extends OverlapBehavior { override def toString = "EARLIEST_ON_TOP" }
case object AVERAGE extends OverlapBehavior { override def toString = "AVERAGE" }
case object RANDOM extends OverlapBehavior { override def toString = "RANDOM" }


case class ColorMapType(colormaptypeoption: scalaxb.DataRecord[opengis.se.ColorMapTypeOption])
      
      

trait ColorMapTypeOption

case class ContrastEnhancementType(contrastenhancementtypeoption: Option[scalaxb.DataRecord[opengis.se.ContrastEnhancementTypeOption]] = None,
  GammaValue: Option[Double] = None)
      
      

trait ContrastEnhancementTypeOption

case class NormalizeType() extends ContrastEnhancementTypeOption
      
      


case class HistogramType() extends ContrastEnhancementTypeOption
      
      


case class ShadedReliefType(BrightnessOnly: Option[Boolean] = None,
  ReliefFactor: Option[Double] = None)
      
      


case class ImageOutlineType(imageoutlinetypeoption: scalaxb.DataRecord[opengis.se.ImageOutlineTypeOption])
      
      

trait ImageOutlineTypeOption

trait FunctionType extends opengis.ogc.ExpressionType {
  def fallbackValue: String
}


case class FormatNumberType(NumericValue: opengis.se.ParameterValueTypable,
  Pattern: String,
  NegativePattern: Option[String] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val decimalPoint = attributes("@decimalPoint").as[String]
  lazy val groupingSeparator = attributes("@groupingSeparator").as[String]
}

      
      


case class FormatDateType(DateValue: opengis.se.ParameterValueTypable,
  Pattern: String,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
}

      
      


case class SubstringType(StringValue: opengis.se.ParameterValueTypable,
  Position: Option[opengis.se.ParameterValueTypable] = None,
  Length: Option[opengis.se.ParameterValueTypable] = None,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
}

      
      


case class ConcatenateType(StringValue: Seq[opengis.se.ParameterValueTypable] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
}

      
      


case class ChangeCaseType(StringValue: opengis.se.ParameterValueTypable,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val direction = attributes.get("@direction") map { _.as[DirectionType]}
}

      
      

sealed trait DirectionType

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

case object ToUpper extends DirectionType { override def toString = "toUpper" }
case object ToLower extends DirectionType { override def toString = "toLower" }


case class TrimType(StringValue: opengis.se.ParameterValueTypable,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val stripOffPosition = attributes.get("@stripOffPosition") map { _.as[StripOffPositionType]}
  lazy val stripOffChar = attributes.get("@stripOffChar") map { _.as[String]}
}

      
      

sealed trait StripOffPositionType

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

case object Leading extends StripOffPositionType { override def toString = "leading" }
case object Trailing extends StripOffPositionType { override def toString = "trailing" }
case object Both extends StripOffPositionType { override def toString = "both" }


case class StringPositionType(LookupString: opengis.se.ParameterValueTypable,
  StringValue: opengis.se.ParameterValueTypable,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val searchDirection = attributes.get("@searchDirection") map { _.as[SearchDirectionType]}
}

      
      

sealed trait SearchDirectionType

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

case object FrontToBack extends SearchDirectionType { override def toString = "frontToBack" }
case object BackToFront extends SearchDirectionType { override def toString = "backToFront" }


case class StringLengthType(StringValue: opengis.se.ParameterValueTypable,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
}

      
      


case class CategorizeType(LookupValue: opengis.se.ParameterValueTypable,
  Value: opengis.se.ParameterValueTypable,
  categorizetypesequence1: Seq[opengis.se.CategorizeTypeSequence1] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType with ColorMapTypeOption {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val threshholdsBelongTo = attributes.get("@threshholdsBelongTo") map { _.as[ThreshholdsBelongToType]}
}

      
      

case class CategorizeTypeSequence1(Threshold: opengis.se.ParameterValueTypable,
  Value: opengis.se.ParameterValueTypable)
      

sealed trait ThreshholdsBelongToType

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

case object Succeeding extends ThreshholdsBelongToType { override def toString = "succeeding" }
case object Preceding extends ThreshholdsBelongToType { override def toString = "preceding" }


case class InterpolateType(LookupValue: opengis.se.ParameterValueTypable,
  InterpolationPoint: Seq[opengis.se.InterpolationPointType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType with ColorMapTypeOption {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
  lazy val mode = attributes.get("@mode") map { _.as[ModeType]}
  lazy val method = attributes.get("@method") map { _.as[MethodType]}
}

      
      


case class InterpolationPointType(Data: Double,
  Value: opengis.se.ParameterValueTypable) extends opengis.ogc.ExpressionType
      
      

sealed trait ModeType

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

case object Linear extends ModeType { override def toString = "linear" }
case object Cosine extends ModeType { override def toString = "cosine" }
case object Cubic extends ModeType { override def toString = "cubic" }

sealed trait MethodType

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

case object Numeric extends MethodType { override def toString = "numeric" }
case object Color extends MethodType { override def toString = "color" }


case class RecodeType(LookupValue: opengis.se.ParameterValueTypable,
  MapItem: Seq[opengis.se.MapItemType] = Nil,
  attributes: Map[String, scalaxb.DataRecord[Any]] = Map.empty) extends FunctionType {
  lazy val fallbackValue = attributes("@fallbackValue").as[String]
}

      
      


case class MapItemType(Data: Double,
  Value: opengis.se.ParameterValueTypable) extends opengis.ogc.ExpressionType




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy