Java Polygon类代码示例

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Writes elements of PolygonType complex type
 */
public void writePolygonTypeElements(XMLStreamWriter writer, Polygon bean) throws XMLStreamException
{
    this.writeAbstractGeometryTypeElements(writer, bean);
    int numItems;
    
    // exterior
    if (bean.isSetExterior())
    {
        writer.writeStartElement(NS_URI, "exterior");
        this.writeLinearRing(writer, bean.getExterior());
        writer.writeEndElement();
    }
    
    // interior
    numItems = bean.getInteriorList().size();
    for (int i = 0; i < numItems; i++)
    {
        LinearRing item = bean.getInteriorList().get(i);
        writer.writeStartElement(NS_URI, "interior");
        this.writeLinearRing(writer, item);
        writer.writeEndElement();
    }
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Dispatcher method for writing classes derived from AbstractSurface
 */
public void writeAbstractSurface(XMLStreamWriter writer, AbstractSurface bean) throws XMLStreamException
{
    /*if (bean instanceof CompositeSurface)
        writeCompositeSurface(writer, (CompositeSurface)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof OrientableSurface)
        writeOrientableSurface(writer, (OrientableSurface)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof Tin)
        writeTin(writer, (Tin)bean);*/
    if (bean instanceof Polygon)
        writePolygon(writer, (Polygon)bean);
    else
        throw new XMLStreamException(ERROR_UNSUPPORTED_TYPE + bean.getClass().getCanonicalName());
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
public SamplingFeature<? extends AbstractGeometry> getAsSpecializedType()
{
    String type = properties.containsKey(PROP_TYPE) ? ((CachedReference<Object>)getProperty(PROP_TYPE)).getHref() : null;
    SamplingFeature<? extends AbstractGeometry> sf = null;
    
    if (SamplingPoint.TYPE.equals(type))
    {
        sf = new SamplingPoint();
        ((SamplingPoint)sf).setShape((Point)getShape());
    }
    else if (SamplingSurface.TYPE.equals(type))
    {
        sf = new SamplingSurface();
        ((SamplingSurface)sf).setShape((Polygon)getShape());
    }
    else if (SamplingCurve.TYPE.equals(type))
    {
        sf = new SamplingCurve();
        ((SamplingCurve)sf).setShape((LineString)getShape());
    }
    else
        throw new UnsupportedOperationException("Unsupported sampling feature type " + type);
    
    sf.setId(getId());
    sf.setIdentifier(getIdentifier());
    sf.setDescription(getDescription());
    sf.setBoundedByAsEnvelope(getBoundedBy());
    sf.setLocation(getLocation());
    sf.setSampledFeatureUID(getSampledFeatureUID());
    sf.setHostedProcedureUID(getHostedProcedureUID());
    
    return sf;
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
@Override
public final Polygon newPolygon()
{
    Polygon poly;
    
    if (useJTS)
        poly = new PolygonJTS(jtsFactory, 2);
    else
        poly = new PolygonImpl(2);
    
    return poly;
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Read method for PolygonType complex type
 */
public Polygon readPolygonType(XMLStreamReader reader) throws XMLStreamException
{
    Polygon bean = factory.newPolygon();
    
    Map<String, String> attrMap = collectAttributes(reader);
    this.readPolygonTypeAttributes(attrMap, bean);
    
    reader.nextTag();
    this.readPolygonTypeElements(reader, bean);
    
    return bean;
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Reads elements of PolygonType complex type
 */
public void readPolygonTypeElements(XMLStreamReader reader, Polygon bean) throws XMLStreamException
{
    this.readAbstractGeometryTypeElements(reader, bean);
    
    boolean found;
    
    // exterior
    found = checkElementName(reader, "exterior");
    if (found)
    {
        reader.nextTag();
        LinearRing exterior = this.readLinearRing(reader);
        if (exterior != null)
            bean.setExterior(exterior);
        
        reader.nextTag(); // end property tag
        reader.nextTag();
    }
    
    // interior
    do
    {
        found = checkElementName(reader, "interior");
        if (found)
        {
            reader.nextTag();
            LinearRing interior = this.readLinearRing(reader);
            if (interior != null)
                bean.addInterior(interior);
            
            reader.nextTag(); // end property tag
            reader.nextTag();
        }
    }
    while (found);
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Read method for Polygon elements
 */
public Polygon readPolygon(XMLStreamReader reader) throws XMLStreamException
{
    boolean found = checkElementName(reader, "Polygon");
    if (!found)
        throw new XMLStreamException(ERROR_INVALID_ELT + reader.getName() + errorLocationString(reader));
    
    return this.readPolygonType(reader);
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Write method for Polygon element
 */
public void writePolygon(XMLStreamWriter writer, Polygon bean) throws XMLStreamException
{
    writer.writeStartElement(NS_URI, "Polygon");
    this.writeNamespaces(writer);
    this.writePolygonType(writer, bean);
    writer.writeEndElement();
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Reads attributes of PolygonType complex type
 */
public void readPolygonTypeAttributes(Map<String, String> attrMap, Polygon bean) throws XMLStreamException
{
    this.readAbstractGeometryTypeAttributes(attrMap, bean);
    
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Write method for PolygonType complex type
 */
public void writePolygonType(XMLStreamWriter writer, Polygon bean) throws XMLStreamException
{
    this.writePolygonTypeAttributes(writer, bean);
    this.writePolygonTypeElements(writer, bean);
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Writes attributes of PolygonType complex type
 */
public void writePolygonTypeAttributes(XMLStreamWriter writer, Polygon bean) throws XMLStreamException
{
    this.writeAbstractGeometryTypeAttributes(writer, bean);
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
/**
 * Dispatcher method for writing classes derived from AbstractGeometry
 */
public void writeAbstractGeometry(XMLStreamWriter writer, AbstractGeometry bean) throws XMLStreamException
{
    /*if (bean instanceof GeometricComplex)
        writeGeometricComplex(writer, (GeometricComplex)bean);
    else if (bean instanceof CompositeCurve)
        writeCompositeCurve(writer, (CompositeCurve)bean);
    else if (bean instanceof CompositeSurface)
        writeCompositeSurface(writer, (CompositeSurface)bean);
    else if (bean instanceof CompositeSolid)
        writeCompositeSolid(writer, (CompositeSolid)bean);
    else if (bean instanceof Grid)
        writeGrid(writer, (Grid)bean);
    else if (bean instanceof RectifiedGrid)
        writeRectifiedGrid(writer, (RectifiedGrid)bean);
    else if (bean instanceof MultiGeometry)
        writeMultiGeometry(writer, (MultiGeometry)bean);
    else if (bean instanceof MultiPoint)
        writeMultiPoint(writer, (MultiPoint)bean);
    else if (bean instanceof MultiCurve)
        writeMultiCurve(writer, (MultiCurve)bean);
    else if (bean instanceof MultiSurface)
        writeMultiSurface(writer, (MultiSurface)bean);
    else if (bean instanceof MultiSolid)
        writeMultiSolid(writer, (MultiSolid)bean);
    else if (bean instanceof Curve)
        writeCurve(writer, (Curve)bean);
    else if (bean instanceof OrientableCurve)
        writeOrientableCurve(writer, (OrientableCurve)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof OrientableSurface)
        writeOrientableSurface(writer, (OrientableSurface)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof Surface)
        writeSurface(writer, (Surface)bean);
    else if (bean instanceof Tin)
        writeTin(writer, (Tin)bean);
    else if (bean instanceof Solid)
        writeSolid(writer, (Solid)bean);*/
    if (bean instanceof Point)
        writePoint(writer, (Point)bean);
    else if (bean instanceof LineString)
        writeLineString(writer, (LineString)bean);
    else if (bean instanceof Polygon)
        writePolygon(writer, (Polygon)bean);
    else
        throw new XMLStreamException(ERROR_UNSUPPORTED_TYPE + bean.getClass().getCanonicalName());
}
 

import net.opengis.gml.v32.Polygon; //导入依赖的package包/类
@Override
protected void writeContents(DOMHelper dom, Element capsElt, OWSServiceCapabilities serviceCaps, String version) throws OWSException
{
    try
       {
           Element contentsElt = dom.addElement(capsElt, "sps:contents/sps:SPSContents");
           SPSServiceCapabilities spsCaps = (SPSServiceCapabilities)serviceCaps;
           
           // SWES properties common to all offerings
           super.writeCommonContentsProperties(dom, contentsElt, serviceCaps);

           // SPS offerings
           for (OWSLayerCapabilities layerCaps: serviceCaps.getLayers())
           {
               // skip disabled offerings
               if (!layerCaps.isEnabled())
                   continue;
               
               Element offeringElt = dom.addElement(contentsElt, "+swes:offering/sps:SensorOffering");
               SPSOfferingCapabilities offering = (SPSOfferingCapabilities)layerCaps;
               
               // SWES offering properties
               super.writeCommonOfferingProperties(dom, offeringElt, serviceCaps, offering);
               
               // observable area
               AbstractGeometry obsArea = offering.getObservableArea();
               if (obsArea != null)
               {
                   Element geomElt = gmlUtils.writeGeometry(dom, obsArea);
                   String path = "sps:observableArea/";
                   if (obsArea instanceof Polygon)
                       path += "sps:byPolygon";
                   else if (obsArea instanceof Point)
                       path += "sps:byPoint";
                   else
                       throw new SPSException("Invalid geometry for observedArea: " + obsArea.getClass().getSimpleName());
                   dom.addElement(offeringElt, path).appendChild(geomElt);
               }
           }
           
           // min status time
           double minStatusTime = spsCaps.getMinStatusTime();
           if (!Double.isNaN(minStatusTime)) 
               dom.setElementValue(contentsElt, "sps:minStatusTime", timeFormat.formatIsoPeriod(minStatusTime, 'D'));
           
           // supported encodings
           for (String encoding: spsCaps.getSupportedEncodings())
               dom.setElementValue(contentsElt, "+sps:supportedEncoding", encoding);
       }
       catch (XMLWriterException e)
       {
           throw new SPSException("Error while writing SPS capabilities", e);
       }
}