wktgeoxygene.jj

用于GIS(全球地理系统)的分析和处理的代码。

    /*- Write to stream -----------------------------------*/

    public static void writeWkt(String path, GM_Object geom)
    throws IOException
    {
		writeWkt(new FileOutputStream(path), geom);
    }

    public static void writeWkt(OutputStream out, GM_Object geom)
    throws IOException
    {
        new PrintStream(out).println(makeWkt(geom));
    }

    public static void writeWkt(OutputStream out, List geomList)
    throws IOException
    {
        Iterator i=geomList.iterator();
        while (i.hasNext()) {
            GM_Object geom=(GM_Object)i.next();
            writeWkt(out,geom);
        }
    }

    /*-----------------------------------------------------*/
    /*- Create GM_Object from Wkt object(s) ---------------*/
    /*-----------------------------------------------------*/

    public static List makeGeOxygeneList(String inStrArray[])
	throws ParseException
    {
        ArrayList list=new ArrayList();
        for (int i=0; i<inStrArray.length; i++) {
            list.add(makeGeOxygene(inStrArray[i]));
        }
        return list;
    }
    
    static GM_Object makeGeOxygene(InputStream in)
    throws ParseException
    {
        WktGeOxygene parser=new WktGeOxygene(in);
        GM_Object geom=null;

        try {
            geom=parser.parseOneLine();
        }
        catch (EndOfFile x) {}
        catch (EmptyLine x) {}

        return geom;
    }

    public static List makeGeOxygeneList(File file)
    throws Exception
    {
        return makeGeOxygeneList(new FileInputStream(file));
    }
    
    public static List makeGeOxygeneList(String wkt)
    throws Exception
    {
    	InputStream in=new ByteArrayInputStream(wkt.getBytes());
    	return makeGeOxygeneList(in);
    }

    public static List makeGeOxygeneList(InputStream in)
    throws ParseException
    {
        ArrayList list=new ArrayList();
        WktGeOxygene parser=new WktGeOxygene(in);

        while (true) {
            try {
                GM_Object geom=parser.parseOneLine();
                list.add(geom);
			} catch (EndOfFile x) {
                break;
            } catch (EmptyLine x) {}
        }
        return list;
    }

    public static GM_Object makeGeOxygene(String inStr)
    throws ParseException
    {
        InputStream in=new ByteArrayInputStream(inStr.getBytes());
        return makeGeOxygene(in);
    }
}

PARSER_END(WktGeOxygene)

TOKEN:
{
    <CONSTANT: (["-","+"])? (
         <FLOAT>
         |<FLOAT>(["e","E"] (["-","+"])?<INTEGER>)?)
    >
    |
    <#FLOAT:
            <INTEGER>
            |<INTEGER>("."<INTEGER>)?
            |"."<INTEGER>
    >
    | <#INTEGER: (<DIGIT>)+>
    | <#DIGIT: ["0" - "9"]>
}

TOKEN:
{
    <POINT: <CONSTANT>(" ")+<CONSTANT>>
}

TOKEN:
{
    <EOL: "\n">
}

SKIP:
{
    "\t"|" "
}

DirectPosition point():
{
    DirectPosition p;
    Token xy;
}
{
    xy=<POINT>
    {
        StringTokenizer tkz=new StringTokenizer(xy.image);
        String xStr=tkz.nextToken();
        String yStr=tkz.nextToken();
        p=new DirectPosition(
            Double.parseDouble(xStr), Double.parseDouble(yStr));
        return p;
    }
}

DirectPosition pointText():
{DirectPosition p=new DirectPosition();}
{
    ("(" p=point() ")" | "EMPTY") {return p;}
}

GM_LineString linestringText():
{
    GM_LineString lineString=new GM_LineString();
    DirectPosition p;
}
{
    ("("
    p=point() {lineString.addControlPoint(p);}
    ("," p=point() {lineString.addControlPoint(p);})*
    ")"
    | "EMPTY")
    {return lineString;}
}

GM_Polygon polygonText():
{
    GM_Polygon polygon=new GM_Polygon();
    GM_LineString lineString;
    DirectPosition start;
    DirectPosition end;
}
{
    ("("
    lineString=linestringText() {
   		polygon=new GM_Polygon(lineString);
   	}
    (
        ","
        lineString=linestringText() {
            polygon.addInterior(new GM_Ring(lineString));
        }
    )*
    ")"
    | "EMPTY")
    {return polygon;}
}

GM_MultiPoint multipointText():
{
    GM_MultiPoint multiPoint=new GM_MultiPoint();
    DirectPosition p;
}
{
    ("("
    p=point() {multiPoint.add(new GM_Point(p));}
    ("," p=point() {multiPoint.add(new GM_Point(p));})*
    ")"
    | "EMPTY")
    {return multiPoint;}
}

GM_MultiCurve multilinestringText():
{
    GM_MultiCurve multiLineString=new GM_MultiCurve();
    GM_LineString lineString;
}
{
    ("("
    lineString=linestringText() {multiLineString.add(lineString);}
    ("," lineString=linestringText()
        {multiLineString.add(lineString);})*
    ")"
    | "EMPTY")
    {return multiLineString;}
}

GM_MultiSurface multipolygonText():
{
    GM_MultiSurface multiPolygon=new GM_MultiSurface();
    GM_Polygon polygon;
}
{
    ("("
    polygon=polygonText() {multiPolygon.add(polygon);}
    ("," polygon=polygonText() {multiPolygon.add(polygon);})*
    ")"
    | "EMPTY")
    {return multiPolygon;}
}

GM_Aggregate geometrycollectionText():
{
    GM_Aggregate geometryCollection=new GM_Aggregate();
    GM_Object geometry;
}
{
    ("("
    geometry=geometryTaggedText() {geometryCollection.add(geometry);}
    ("," geometry=geometryTaggedText()
        {geometryCollection.add(geometry);}
    )*
    ")"
    | "EMPTY")
    {return geometryCollection;}
}

GM_Point pointTaggedText():
{DirectPosition p;}
{
    "POINT"
    (p=pointText() {return new GM_Point(p);})
}

GM_MultiPoint multipointTaggedText():
{GM_MultiPoint mp;}
{
    "MULTIPOINT"
    (mp=multipointText() {return mp;})
}

GM_LineString linestringTaggedText():
{GM_LineString lineString;}
{
    "LINESTRING"
    (lineString=linestringText() {return lineString;})
}

GM_MultiCurve multilinestringTaggedText():
{GM_MultiCurve multiLineString;}
{
    "MULTILINESTRING"
    (multiLineString=multilinestringText() {return multiLineString;})
}

GM_Polygon polygonTaggedText():
{GM_Polygon poly;}
{
    "POLYGON"
    (poly=polygonText() {return poly;})
}

GM_MultiSurface multipolygonTaggedText():
{GM_MultiSurface mp;}
{
    "MULTIPOLYGON"
    (mp=multipolygonText() {return mp;})
}

GM_Aggregate geometrycollectionTaggedText():
{GM_Aggregate o;}
{
    "GEOMETRYCOLLECTION"
    (o=geometrycollectionText() {return o;})
}


GM_Object geometryTaggedText():
{GM_Object o;}
{
    (
    o=pointTaggedText()
    | o=linestringTaggedText()
    | o=polygonTaggedText()
    | o=multipointTaggedText()
    | o=multilinestringTaggedText()
    | o=multipolygonTaggedText()
    | o=geometrycollectionTaggedText()
    )
    {return o;}
}

GM_Object parseOneLine() throws EmptyLine,EndOfFile:
{GM_Object o;}
{
    (o=geometryTaggedText())(<EOL>|<EOF>) {return o;}
    | <EOL> {throw new EmptyLine(); return null;}
    | <EOF> {throw new EndOfFile(); return null;}
}