    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/model/spatialschema/WKTAdapter.java $
    002    /*----------------------------------------------------------------------------
    003     This file is part of deegree, http://deegree.org/
    004     Copyright (C) 2001-2009 by:
    005       Department of Geography, University of Bonn
    006     and
    007       lat/lon GmbH
    008
    009     This library is free software; you can redistribute it and/or modify it under
    010     the terms of the GNU Lesser General Public License as published by the Free
    011     Software Foundation; either version 2.1 of the License, or (at your option)
    012     any later version.
    013     This library is distributed in the hope that it will be useful, but WITHOUT
    014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    016     details.
    017     You should have received a copy of the GNU Lesser General Public License
    018     along with this library; if not, write to the Free Software Foundation, Inc.,
    019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    020
    021     Contact information:
    022
    023     lat/lon GmbH
    024     Aennchenstr. 19, 53177 Bonn
    025     Germany
    026     http://lat-lon.de/
    027
    028     Department of Geography, University of Bonn
    029     Prof. Dr. Klaus Greve
    030     Postfach 1147, 53001 Bonn
    031     Germany
    032     http://www.geographie.uni-bonn.de/deegree/
    033
    034     e-mail: info@deegree.org
    035    ----------------------------------------------------------------------------*/
    036    package org.deegree.model.spatialschema;
    037
    038    import java.util.ArrayList;
    039
    040    import org.deegree.framework.util.StringTools;
    041    import org.deegree.model.crs.CoordinateSystem;
    042
    043    /**
    044     * Adapter class for exporting deegree geometries to WKT and to wrap WKT code geometries to deegree geometries.
    045     *
    046     * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
    047     * @author last edited by: $Author: mschneider $
    048     *
    049     * @version $Revision: 18195 $
    050     */
    051    public class WKTAdapter {
    052
    053        /**
    054         *
    055         *
    056         * @param wkt
    057         * @param crs
    058         * @return the corresponding <tt>Geometry</tt>
    059         * @throws GeometryException
    060         *             if type unsupported or conversion failed
    061         */
    062        public static Geometry wrap( String wkt, CoordinateSystem crs )
    063                                throws GeometryException {
    064            if ( wkt == null || "".equals( wkt.trim() ) ) {
    065                throw new NullPointerException( "No Well-Known-Text (WKT) to parse geometry from." );
    066            }
    067            Geometry geo = null;
    068
    069            if ( wkt.startsWith( "POINT" ) ) {
    070                geo = wrapPoint( wkt, crs );
    071            } else if ( wkt.startsWith( "LINE" ) ) {
    072                geo = wrapCurve( wkt, crs );
    073            } else if ( wkt.startsWith( "POLY" ) ) {
    074                geo = wrapSurface( wkt, crs );
    075            } else if ( wkt.startsWith( "MULTIPOINT" ) ) {
    076                geo = wrapMultiPoint( wkt, crs );
    077            } else if ( wkt.startsWith( "MULTILINE" ) ) {
    078                geo = wrapMultiCurve( wkt, crs );
    079            } else if ( wkt.startsWith( "MULTIPOLY" ) ) {
    080                geo = wrapMultiSurface( wkt, crs );
    081            } else {
    082                throw new GeometryException( "Not supported Well-Known-Text: " + wkt );
    083            }
    084
    085            return geo;
    086        }
    087
    088        /**
    089         * @param geom
    090         *            geometry
    091         *
    092         * @return the StingBuffer containing the exported geometry
    093         * @throws GeometryException
    094         */
    095        public static StringBuffer export( Geometry geom )
    096                                throws GeometryException {
    097
    098            if ( geom == null ) {
    099                throw new NullPointerException( "The Geometry is empty, cannot create wkt for it." );
    100            }
    101            StringBuffer sb = null;
    102            if ( geom instanceof Point ) {
    103                sb = export( (Point) geom );
    104            } else if ( geom instanceof Curve ) {
    105                sb = export( (Curve) geom );
    106            } else if ( geom instanceof Surface ) {
    107                sb = export( (Surface) geom );
    108            } else if ( geom instanceof MultiPoint ) {
    109                sb = export( (MultiPoint) geom );
    110            } else if ( geom instanceof MultiCurve ) {
    111                sb = export( (MultiCurve) geom );
    112            } else if ( geom instanceof MultiSurface ) {
    113                sb = export( (MultiSurface) geom );
    114            } else if ( geom instanceof MultiGeometry ) {
    115                sb = export( (MultiGeometry) geom );
    116            }
    117
    118            return sb;
    119        }
    120
    121        /**
    122         * exports an Envelope as a BOX3D WKT string.
    123         *
    124         * @param envelope
    125         * @return the StringBuffer containing the exported envelope
    126         */
    127        public static StringBuffer export( Envelope envelope ) {
    128            if ( envelope == null ) {
    129                throw new NullPointerException( "The envelope is empty, cannot create wkt for it." );
    130            }
    131            StringBuffer sb = new StringBuffer( 150 );
    132            sb.append( "BOX3D(" );
    133            int dim = envelope.getMin().getCoordinateDimension();
    134            double[] d = envelope.getMin().getAsArray();
    135            for ( int i = 0; i < dim - 1; i++ ) {
    136                sb.append( Double.toString( d[i] ) ).append( " " );
    137            }
    138            sb.append( Double.toString( d[dim - 1] ) ).append( "," );
    139            d = envelope.getMax().getAsArray();
    140            for ( int i = 0; i < dim - 1; i++ ) {
    141                sb.append( Double.toString( d[i] ) ).append( " " );
    142            }
    143            sb.append( Double.toString( d[dim - 1] ) );
    144            sb.append( ") " );
    145            return sb;
    146        }
    147
    148        /**
    149         * @param point
    150         *            point geometry
    151         *
    152         * @return the StringBuffer containing the exported point
    153         */
    154        private static StringBuffer export( Point point ) {
    155
    156            StringBuffer sb = new StringBuffer( 50 );
    157            sb.append( "POINT(" );
    158            double[] points = point.getAsArray();
    159            int dim = point.getCoordinateDimension();
    160            for ( int i = 0; i < dim - 1; i++ ) {
    161                sb.append( points[i] ).append( ' ' );
    162            }
    163            sb.append( points[dim - 1] );
    164            sb.append( ") " );
    165
    166            return sb;
    167        }
    168
    169        /**
    170         *
    171         * @param cur
    172         *            curve geometry
    173         *
    174         * @return the StringBuffer containing the exported curve
    175         *
    176         * @throws GeometryException
    177         */
    178        private static StringBuffer export( Curve cur )
    179                                throws GeometryException {
    180
    181            LineString ls = cur.getAsLineString();
    182
    183            StringBuffer sb = new StringBuffer( ls.getNumberOfPoints() * 30 );
    184            sb.append( "LINESTRING(" );
    185
    186            for ( int i = 0; i < ls.getNumberOfPoints() - 1; i++ ) {
    187                Position pos = ls.getPositionAt( i );
    188                double[] positions = pos.getAsArray();
    189                int dim = pos.getCoordinateDimension();
    190                for ( int j = 0; j < dim - 1; j++ ) {
    191                    sb.append( positions[j] + " " );
    192                }
    193                sb.append( positions[dim - 1] + "," );
    194            }
    195            Position pos = ls.getPositionAt( ls.getNumberOfPoints() - 1 );
    196            double[] tmp = pos.getAsArray();
    197            int dim = pos.getCoordinateDimension();
    198            for ( int j = 0; j < dim - 1; j++ ) {
    199                sb.append( tmp[j] + " " );
    200            }
    201            sb.append( tmp[dim - 1] + ")" );
    202
    203            return sb;
    204        }
    205
    206        /**
    207         *
    208         *
    209         * @param sur
    210         *
    211         * @return the StringBuffer containing the exported surface
    212         *
    213         */
    214        private static StringBuffer export( Surface sur ) {
    215
    216            SurfaceBoundary subo = sur.getSurfaceBoundary();
    217            Ring exter = subo.getExteriorRing();
    218            Ring[] inter = subo.getInteriorRings();
    219
    220            StringBuffer sb = new StringBuffer( 10000 );
    221            sb.append( "POLYGON((" );
    222            // exterior ring
    223            Position[] pos = exter.getPositions();
    224            int dim = pos[0].getCoordinateDimension();
    225            for ( int i = 0; i < pos.length - 1; i++ ) {
    226                double[] positions = pos[i].getAsArray();
    227                for ( int j = 0; j < dim - 1; j++ ) {
    228                    sb.append( positions[j] + " " );
    229                }
    230                sb.append( positions[dim - 1] + "," );
    231            }
    232            double[] positions = pos[pos.length - 1].getAsArray();
    233            for ( int j = 0; j < dim - 1; j++ ) {
    234                sb.append( positions[j] + " " );
    235            }
    236            sb.append( positions[dim - 1] + ")" );
    237            // interior rings
    238            if ( inter != null ) {
    239                for ( int j = 0; j < inter.length; j++ ) {
    240                    sb.append( ",(" );
    241                    pos = inter[j].getPositions();
    242                    for ( int i = 0; i < pos.length - 1; i++ ) {
    243                        double[] intPos = pos[i].getAsArray();
    244                        for ( int l = 0; l < dim - 1; l++ ) {
    245                            sb.append( intPos[l] + " " );
    246                        }
    247                        sb.append( intPos[dim - 1] + "," );//
    248                    }
    249                    double[] intPos = pos[pos.length - 1].getAsArray();
    250                    for ( int l = 0; l < dim - 1; l++ ) {
    251                        sb.append( intPos[l] + " " );
    252                    }
    253                    sb.append( intPos[dim - 1] + ")" );
    254                }
    255            }
    256            sb.append( ")" );
    257
    258            return sb;
    259        }
    260
    261        /**
    262         * @param mp
    263         * @return the StringBuffer containing the exported multipoint
    264         */
    265        private static StringBuffer export( MultiPoint mp ) {
    266
    267            StringBuffer sb = new StringBuffer( mp.getSize() * 30 );
    268            sb.append( "MULTIPOINT(" );
    269            int dim = mp.getPointAt( 0 ).getCoordinateDimension();
    270            for ( int i = 0; i < mp.getSize() - 1; i++ ) {
    271                Point pt = mp.getPointAt( i );
    272                double[] points = pt.getAsArray();
    273                for ( int j = 0; j < dim - 1; j++ ) {
    274                    sb.append( points[j] + " " );
    275                }
    276                sb.append( points[dim - 1] );
    277                sb.append( "," );
    278            }
    279            Point pt = mp.getPointAt( mp.getSize() - 1 );
    280            double[] points = pt.getAsArray();
    281            for ( int j = 0; j < dim - 1; j++ ) {
    282                sb.append( points[j] + " " );
    283            }
    284            sb.append( points[dim - 1] + ")" );
    285
    286            return sb;
    287        }
    288
    289        /**
    290         *
    291         *
    292         * @param mc
    293         *
    294         * @return the StringBuffer containing the exported multi curve
    295         *
    296         * @throws GeometryException
    297         */
    298        private static StringBuffer export( MultiCurve mc )
    299                                throws GeometryException {
    300
    301            StringBuffer sb = new StringBuffer( 10000 );
    302            sb.append( "MULTILINESTRING(" );
    303
    304            for ( int i = 0; i < mc.getSize() - 1; i++ ) {
    305                String s = export( mc.getCurveAt( i ) ).toString();
    306                s = s.substring( 10, s.length() );
    307                sb.append( s ).append( "," );
    308            }
    309            String s = export( mc.getCurveAt( mc.getSize() - 1 ) ).toString();
    310            s = s.substring( 10, s.length() );
    311            sb.append( s ).append( ")" );
    312
    313            return sb;
    314        }
    315
    316        /**
    317         *
    318         *
    319         * @param ms
    320         *
    321         * @return the StringBuffer containing the exported multi surface
    322         *
    323         */
    324        private static StringBuffer export( MultiSurface ms ) {
    325
    326            StringBuffer sb = new StringBuffer( 10000 );
    327            sb.append( "MULTIPOLYGON(" );
    328
    329            for ( int i = 0; i < ms.getSize() - 1; i++ ) {
    330                String s = export( ms.getSurfaceAt( i ) ).toString();
    331                s = s.substring( 7, s.length() );
    332                sb.append( s ).append( "," );
    333            }
    334            String s = export( ms.getSurfaceAt( ms.getSize() - 1 ) ).toString();
    335            s = s.substring( 7, s.length() );
    336            sb.append( s ).append( ")" );
    337
    338            return sb;
    339        }
    340
    341        private static StringBuffer export( MultiGeometry multi )
    342                                throws GeometryException {
    343            StringBuffer sb = new StringBuffer( 10000 );
    344            sb.append( "GEOMETRYCOLLECTION(" );
    345
    346            for ( int i = 0; i < multi.getSize() - 1; i++ ) {
    347                StringBuffer memberWKT = export( multi.getObjectAt( i ) );
    348                sb.append( memberWKT ).append( "," );
    349            }
    350
    351            StringBuffer memberWKT = export( multi.getObjectAt( multi.getSize() - 1 ) );
    352            sb.append( memberWKT ).append( ")" );
    353            return sb;
    354        }
    355
    356        /**
    357         * creates a Point from a WKT.
    358         *
    359         * @param wkt
    360         *            a Point WKT
    361         * @param crs
    362         * @return the point created from the given wkt
    363         * @throws GeometryException
    364         */
    365        public static Point wrapPoint( String wkt, CoordinateSystem crs )
    366                                throws GeometryException {
    367            if ( wkt == null || "".equals( wkt.trim() ) ) {
    368                throw new NullPointerException( "No Well-Known-Text (WKT) to parse point from." );
    369            }
    370            wkt = wkt.trim();
    371            wkt = wkt.substring( 6, wkt.length() - 1 );
    372            double[] tmp = createDoubles( wkt );// StringTools.toArrayDouble( wkt, " " );
    373            Position pos = GeometryFactory.createPosition( tmp );
    374            Point point = GeometryFactory.createPoint( pos, crs );
    375
    376            return point;
    377        }
    378
    379        /**
    380         * creates a Curve from a WKT.
    381         *
    382         * @param wkt
    383         *            linestring a WKT
    384         * @param crs
    385         * @return the curve created from the given wkt.
    386         * @throws GeometryException
    387         */
    388        public static Curve wrapCurve( String wkt, CoordinateSystem crs )
    389                                throws GeometryException {
    390            if ( wkt == null || "".equals( wkt.trim() ) ) {
    391                throw new NullPointerException( "No Well-Known-Text (WKT) to parse curve from." );
    392            }
    393            wkt = wkt.trim();
    394            wkt = wkt.substring( 11, wkt.length() - 1 );
    395            String[] points = wkt.split( "," );// StringTools.toArray( wkt, ",", false );
    396            Position[] pos = new Position[points.length];
    397            for ( int i = 0; i < points.length; i++ ) {
    398                double[] tmp = StringTools.toArrayDouble( points[i], " " );
    399                pos[i] = GeometryFactory.createPosition( tmp );
    400            }
    401            Curve curve = GeometryFactory.createCurve( pos, crs );
    402
    403            return curve;
    404        }
    405
    406        /**
    407         * creates a Surface
    408         *
    409         * @param wkt
    410         *            polygon WKT
    411         * @param crs
    412         * @return the Surface created from the given wkt.
    413         * @throws GeometryException
    414         */
    415        public static Surface wrapSurface( String wkt, CoordinateSystem crs )
    416                                throws GeometryException {
    417            if ( wkt == null || "".equals( wkt.trim() ) ) {
    418                throw new NullPointerException( "No Well-Known-Text (WKT) to parse surface from." );
    419            }
    420            wkt = wkt.trim();
    421
    422            Position[] ext = null;
    423            ArrayList<Position[]> inn = new ArrayList<Position[]>();
    424            if ( wkt.indexOf( "((" ) > 0 ) {
    425                wkt = wkt.substring( 9, wkt.length() - 1 );
    426                int pos = wkt.indexOf( ")" );
    427                String tmp = wkt.substring( 0, pos );
    428                // external ring
    429                String[] points = tmp.split( "," );// StringTools.toArray( tmp, ",", false );
    430                ext = new Position[points.length];
    431                for ( int i = 0; i < points.length; i++ ) {
    432                    double[] temp = StringTools.toArrayDouble( points[i], " " );
    433                    ext[i] = GeometryFactory.createPosition( temp );
    434                }
    435                if ( pos + 3 < wkt.length() ) {
    436                    wkt = wkt.substring( pos + 3, wkt.length() );
    437                    while ( wkt.indexOf( ")" ) > 0 ) {
    438                        pos = wkt.indexOf( ")" );
    439                        tmp = wkt.substring( 0, pos );
    440                        // internal ring(s)
    441                        points = tmp.split( "," );// StringTools.toArray( tmp, ",", false );
    442                        Position[] intern = new Position[points.length];
    443                        for ( int i = 0; i < points.length; i++ ) {
    444                            double[] temp = StringTools.toArrayDouble( points[i], " " );
    445                            intern[i] = GeometryFactory.createPosition( temp );
    446                        }
    447                        inn.add( intern );
    448                        if ( pos + 3 < wkt.length() ) {
    449                            wkt = wkt.substring( pos + 3, wkt.length() );
    450                        } else {
    451                            break;
    452                        }
    453                    }
    454                }
    455            }
    456            Position[][] inner = null;
    457            if ( inn.size() > 0 ) {
    458                inner = inn.toArray( new Position[inn.size()][] );
    459            }
    460            Surface sur = GeometryFactory.createSurface( ext, inner, new SurfaceInterpolationImpl(), crs );
    461
    462            return sur;
    463        }
    464
    465        /**
    466         * creates a MultiPoint from a WKT
    467         *
    468         * @param wkt
    469         *            multipoint WKT
    470         * @param crs
    471         * @return the Multipoint created from the given wkt.
    472         */
    473        public static MultiPoint wrapMultiPoint( String wkt, CoordinateSystem crs ) {
    474            if ( wkt == null || "".equals( wkt.trim() ) ) {
    475                throw new NullPointerException( "No Well-Known-Text (WKT) to parse multi point from." );
    476            }
    477            wkt = wkt.trim();
    478            wkt = wkt.substring( 11, wkt.length() - 1 );
    479            String[] coords = wkt.split( "," );// StringTools.toArray( wkt, ",", false );
    480            Position[] pos = new Position[coords.length];
    481            for ( int i = 0; i < coords.length; i++ ) {
    482                double[] temp = StringTools.toArrayDouble( coords[i], " " );
    483                pos[i] = GeometryFactory.createPosition( temp );
    484            }
    485
    486            Point[] points = new Point[pos.length];
    487            for ( int i = 0; i < pos.length; i++ ) {
    488                points[i] = GeometryFactory.createPoint( pos[i], crs );
    489            }
    490            MultiPoint mp = GeometryFactory.createMultiPoint( points );
    491
    492            return mp;
    493        }
    494
    495        /**
    496         * creates a MultiCurve from a WKT
    497         *
    498         * @param wkt
    499         *            a WKT
    500         * @param crs
    501         * @return the multi curve created from the given wkt.
    502         * @throws GeometryException
    503         */
    504        public static MultiCurve wrapMultiCurve( String wkt, CoordinateSystem crs )
    505                                throws GeometryException {
    506            if ( wkt == null || "".equals( wkt.trim() ) ) {
    507                throw new NullPointerException( "No Well-Known-Text (WKT) to parse multi-curve from." );
    508            }
    509            ArrayList<Curve> crvs = new ArrayList<Curve>();
    510
    511            wkt = wkt.trim();
    512            int pos = wkt.indexOf( ")" );
    513            String tmp = wkt.substring( 17, pos );
    514            String[] coords = tmp.split( "," );// StringTools.toArray( tmp, ",", false );
    515            Position[] posi = new Position[coords.length];
    516            for ( int i = 0; i < coords.length; i++ ) {
    517                double[] temp = StringTools.toArrayDouble( coords[i], " " );
    518                posi[i] = GeometryFactory.createPosition( temp );
    519            }
    520            crvs.add( GeometryFactory.createCurve( posi, crs ) );
    521            wkt = wkt.substring( pos + 3, wkt.length() - 1 );
    522            while ( wkt.indexOf( ")" ) > 0 ) {
    523                Position[] posi2 = new Position[coords.length];
    524                pos = wkt.indexOf( ")" );
    525                tmp = wkt.substring( 0, pos );
    526                coords = tmp.split( "," );// StringTools.toArray( tmp, ",", false );
    527                for ( int i = 0; i < coords.length; i++ ) {
    528                    double[] temp = StringTools.toArrayDouble( coords[i], " " );
    529                    posi2[i] = GeometryFactory.createPosition( temp );
    530                }
    531                crvs.add( GeometryFactory.createCurve( posi2, crs ) );
    532                if ( pos + 3 < wkt.length() ) {
    533                    wkt = wkt.substring( pos + 3, wkt.length() );
    534                } else {
    535                    break;
    536                }
    537            }
    538
    539            Curve[] curves = crvs.toArray( new Curve[crvs.size()] );
    540            MultiCurve mc = GeometryFactory.createMultiCurve( curves );
    541
    542            return mc;
    543        }
    544
    545        /**
    546         * creates a MultiSurface from a WKT
    547         *
    548         * @param wkt
    549         *            a WKT
    550         * @param crs
    551         * @return the multi surface created from the given wkt.
    552         * @throws GeometryException
    553         */
    554        public static MultiSurface wrapMultiSurface( String wkt, CoordinateSystem crs )
    555                                throws GeometryException {
    556            if ( wkt == null || "".equals( wkt.trim() ) ) {
    557                throw new NullPointerException( "No Well-Known-Text (WKT) to parse multi-surface from." );
    558            }
    559            ArrayList<Surface> srfcs = new ArrayList<Surface>();
    560
    561            wkt = wkt.substring( 13 );
    562            // for each polygon
    563            while ( wkt.indexOf( "((" ) > -1 ) {
    564                Position[] ext = null;
    565                ArrayList<Position[]> inn = new ArrayList<Position[]>();
    566                int pos1 = wkt.indexOf( "))" );
    567                String tmp = wkt.substring( 2, pos1 + 1 );
    568                // exterior ring
    569                int pos = tmp.indexOf( ")" );
    570                String tmp2 = tmp.substring( 0, pos );
    571                String[] points = tmp2.split( "," );// StringTools.toArray( tmp2, ",", false );
    572                ext = new Position[points.length];
    573                for ( int i = 0; i < points.length; i++ ) {
    574                    double[] temp = StringTools.toArrayDouble( points[i], " " );
    575                    ext[i] = GeometryFactory.createPosition( temp );
    576                }
    577                if ( pos + 3 < tmp.length() ) {
    578                    tmp = tmp.substring( pos + 3, tmp.length() );
    579                    // for each inner ring
    580                    while ( tmp.indexOf( ")" ) > 0 ) {
    581                        pos = tmp.indexOf( ")" );
    582                        tmp2 = tmp.substring( 0, pos );
    583                        points = tmp2.split( "," );// StringTools.toArray( tmp2, ",", false );
    584                        Position[] intern = new Position[points.length];
    585                        for ( int i = 0; i < points.length; i++ ) {
    586                            double[] temp = StringTools.toArrayDouble( points[i], " " );
    587                            intern[i] = GeometryFactory.createPosition( temp );
    588                        }
    589                        inn.add( intern );
    590                        if ( pos + 3 < tmp.length() ) {
    591                            tmp = tmp.substring( pos + 3, tmp.length() );
    592                        } else {
    593                            break;
    594                        }
    595                    }
    596                }
    597                Position[][] inner = null;
    598                if ( inn.size() > 0 ) {
    599                    inner = inn.toArray( new Position[inn.size()][] );
    600                }
    601                Surface sur = GeometryFactory.createSurface( ext, inner, new SurfaceInterpolationImpl(), crs );
    602                srfcs.add( sur );
    603                wkt = wkt.substring( pos1 + 3 );
    604            }
    605            Surface[] surfaces = srfcs.toArray( new Surface[srfcs.size()] );
    606            MultiSurface ms = GeometryFactory.createMultiSurface( surfaces );
    607
    608            return ms;
    609        }
    610
    611        private static double[] createDoubles( String toSeparate )
    612                                throws GeometryException {
    613            if ( toSeparate == null || "".equals( toSeparate.trim() ) ) {
    614                throw new NullPointerException( "The given wkt geometry does not contain coordinates." );
    615            }
    616            String delimiter = " ";
    617            String[] doubs = toSeparate.split( delimiter );
    618            int cnt = 0;
    619            for ( int i = 0; i < doubs.length; i++ ) {
    620                if ( doubs[i] != null && !"".equals( doubs[i] ) ) {
    621                    cnt++;
    622                }
    623            }
    624            double[] result = null;
    625            if ( doubs != null ) {
    626                result = new double[cnt];
    627                cnt = 0;
    628                for ( int i = 0; i < doubs.length; ++i ) {
    629                    String d = doubs[i];
    630                    if ( d != null && !"".equals( d ) ) {
    631                        try {
    632                            result[cnt++] = Double.valueOf( d );
    633                        } catch ( NumberFormatException e ) {
    634                            throw new GeometryException( "The given WKT is not valid at position: " + i + ". Message: "
    635                                                         + e.getLocalizedMessage() );
    636                        }
    637                    }
    638                }
    639            } else {
    640                throw new NullPointerException( "The given wkt geometry does not contain coordinates." );
    641            }
    642
    643            return result;
    644        }
    645    }