Changeset 47:59d921de8db6


Ignore:
Timestamp:
03/14/12 15:07:27 (6 years ago)
Author:
Manos Karpathiotakis <mk@…>
Branch:
default
Message:

Added support for CRS in cases evaluated in Java. SRID is now fetched along with each geometry and stored in StrabonPolyhedron?

Files:
10 edited

Legend:

Unmodified
Added
Removed
  • evaluation/pom.xml

    r36 r47  
    1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 
     1<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     2        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 
    23 
    34        <modelVersion>4.0.0</modelVersion> 
     
    3637                        <version>${sesame.version}</version> 
    3738                </dependency> 
    38                 <!-- 
    39                 <dependency> 
    40                         <groupId>info.aduna.commons</groupId> 
    41                         <artifactId>aduna-commons-lang</artifactId> 
    42                         <version>2.10.0-SNAPSHOT</version> 
    43                 </dependency> 
    44                 --> 
     39                <!-- <dependency> <groupId>info.aduna.commons</groupId> <artifactId>aduna-commons-lang</artifactId>  
     40                        <version>2.10.0-SNAPSHOT</version> </dependency> --> 
    4541                <dependency> 
    4642                        <groupId>org.slf4j</groupId> 
     
    5652                        <artifactId>junit</artifactId> 
    5753                </dependency> 
     54 
     55                <!-- <dependency> --> 
     56                <!-- <groupId>org.opengis</groupId> --> 
     57                <!-- <artifactId>geoapi</artifactId> --> 
     58                <!-- </dependency> --> 
    5859                <dependency> 
    59                         <groupId>org.opengis</groupId> 
    60                         <artifactId>geoapi</artifactId> 
     60                        <groupId>org.geotools</groupId> 
     61                        <artifactId>gt-opengis</artifactId> 
    6162                </dependency> 
     63 
    6264                <dependency> 
    6365                        <groupId>org.geotools</groupId> 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/function/spatial/StrabonPolyhedron.java

    r26 r47  
    3737        public static String TABLE_SUBJ_OBJ_TYPES = "tableProperties.bin"; 
    3838        public static String TABLE_SHIFTING = "groupbys.bin"; 
    39          
    40          
     39 
     40 
    4141        public static final boolean EnableConstraintRepresentation = false; 
    4242 
     
    8383        public static final String extent="http://strdf.di.uoa.gr/ontology#extent"; 
    8484        //// 
    85          
     85 
    8686        //GEOSPARQL 
    87          
     87 
    8888        //Non-topological 
    8989        public static final String geoSparqlDistance = geof+"distance"; //3 arguments 
     
    9696        public static final String geoSparqlEnvelope = geof+"envelope"; 
    9797        public static final String geoSparqlBoundary = geof+"boundary"; 
    98          
     98 
    9999        //Simple Features - 8 functions - all with 2 arguments + boolean 
    100100        public static final String sfEquals = geof+"sf-equals";   
     
    106106        public static final String sfContains = geof+"sf-contains"; 
    107107        public static final String sfOverlaps = geof+"sf-overlaps"; 
    108          
     108 
    109109        //Egenhofer - 8 functions - all with 2 arguments + boolean 
    110110        public static final String ehEquals = geof+"eh-equals";   
     
    128128 
    129129        public static final String geoSparqlRelate = geof+"relate"; 
    130          
     130 
    131131        private static int MAX_POINTS = Integer.MAX_VALUE;//40000;//Integer.MAX_VALUE;//10000; 
    132132 
     
    135135        public StrabonPolyhedron() { 
    136136                this.geometry = null; 
    137         } 
    138          
    139                  
     137 
     138        } 
     139 
     140 
    140141        public void setGeometry(Geometry geometry) { 
    141142                this.geometry = geometry; 
     
    147148                return new StrabonPolyhedron(new WKBReader().read(byteArray)); 
    148149        } 
    149          
     150 
    150151        public static Geometry convertSRID(Geometry A, int sourceSRID, int targetSRID) 
    151152        { 
    152153 
    153                 MathTransform transform; 
    154                 try { 
    155                         //EPSG supported currently - is there a way to be more general?? 
    156                         CoordinateReferenceSystem sourceCRS = CRS.decode("EPSG:"+sourceSRID); 
    157                         CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:"+targetSRID); 
    158                         transform = CRS.findMathTransform(sourceCRS, targetCRS, true); 
    159                         return JTS.transform(A, transform); 
    160                 } catch (FactoryException e) { 
    161                         // TODO Auto-generated catch block 
    162                         e.printStackTrace(); 
    163                 } catch (MismatchedDimensionException e) { 
    164                         // TODO Auto-generated catch block 
    165                         e.printStackTrace(); 
    166                 } catch (TransformException e) { 
    167                         System.out.println("Transformation is not possible!!"); 
    168                         e.printStackTrace(); 
    169                 }  
     154                if(sourceSRID != targetSRID) 
     155                { 
     156                        CoordinateReferenceSystem sourceCRS = null; 
     157                        CoordinateReferenceSystem targetCRS = null; 
     158                         
     159                        MathTransform transform; 
     160                        try { 
     161                                //EPSG supported currently - is there a way to be more general?? 
     162                                sourceCRS = CRS.decode("EPSG:"+sourceSRID); 
     163                                targetCRS = CRS.decode("EPSG:"+targetSRID); 
     164                                transform = CRS.findMathTransform(sourceCRS, targetCRS, true); 
     165 
     166                                Geometry x = JTS.transform(A, transform); 
     167                                x.setSRID(targetSRID); 
     168                                return x; 
     169                        } catch (FactoryException e) { 
     170                                // TODO Auto-generated catch block 
     171                                e.printStackTrace(); 
     172                        } catch (MismatchedDimensionException e) { 
     173                                // TODO Auto-generated catch block 
     174                                e.printStackTrace(); 
     175                        } catch (TransformException e) { 
     176                                System.out.println("Transformation is not possible!!"); 
     177                                e.printStackTrace(); 
     178                        }  
     179                } 
    170180                return A; 
    171181        } 
     
    175185        //      this.geometry = new WKTReader().read(poly.toWKT()); 
    176186        //} 
    177          
     187 
     188 
     189 
    178190        public StrabonPolyhedron(Geometry geo) throws Exception { 
    179191                this.geometry = new StrabonPolyhedron(geo, 1).geometry; 
     
    183195                this.geometry = new StrabonPolyhedron(geo, algorithm, MAX_POINTS).geometry; 
    184196        } 
    185          
     197 
    186198        public StrabonPolyhedron(Geometry geo, int algorithm, int maxPoints) throws Exception {          
    187199                if (geo.isEmpty()) { 
     
    189201                        return; 
    190202                } 
    191                  
     203 
    192204                if (!EnableConstraintRepresentation) { 
    193205                        this.geometry = geo; 
    194206                        return; 
    195207                } 
    196                  
     208 
    197209                //always returns true... 
    198210                //if (!geo.isSimple()) 
     
    210222                        //      this.geometry = new StrabonPolyhedron(geo, algorithm, maxPoints).geometry; 
    211223                        //} else { 
    212                                 this.geometry = new StrabonPolyhedron((Polygon) geo, algorithm, maxPoints).geometry; 
     224                        this.geometry = new StrabonPolyhedron((Polygon) geo, algorithm, maxPoints).geometry; 
    213225                        //} 
    214226                } else if (MultiPoint.class.isInstance(geo)) { 
     
    237249                        this.geometry = new MultiLineString(linecollection, new GeometryFactory()); 
    238250                } else if (MultiPolygon.class.isInstance(geo)) { 
    239 //                      if (!geo.isValid()) { 
    240 ////                            System.out.println("Non valid " + FindGeoType(geo) + " found."); 
    241 ////                            geo = geo.buffer(0.0); 
    242 ////                             
    243 ////                            Geometry[] geometries = new Geometry[geo.getNumGeometries()]; 
    244 ////                            for (int i = 0; i < geo.getNumGeometries(); i++) { 
    245 ////                                    boolean before = geo.getGeometryN(i).isValid(); 
    246 ////                                    geometries[i] = geo.getGeometryN(i).buffer(0.0); 
    247 ////                                    boolean after = geometries[i].isValid(); 
    248 ////                                    //System.out.println("Geometry " + i + " was " + (before ? "" : "not ") + "valid and now it is " + (after ? "still " : "not ") + "valid."); 
    249 ////                            }                        
    250 ////                             
    251 ////                            Geometry col = new GeometryCollection(geometries, new GeometryFactory()).buffer(0.0); 
    252 ////                            System.out.println("Converted to a "+FindGeoType(col)+" that is "+(col.isValid() ? "" : "not ")+"valid."); 
    253 ////                            this.geometry = new StrabonPolyhedron(col, algorithm, maxPoints).geometry; 
    254 //                               
    255 ////                            System.out.println("Non valid " + FindGeoType(geo) + " found."); 
    256 ////                             
    257 ////                            System.out.println("Number of geometries: " + geo.getNumGeometries()); 
    258 ////                            MultiPolygon multipoly = (MultiPolygon)geo; 
    259 ////                            Geometry newPoly = multipoly.getGeometryN(0); 
    260 ////                             
    261 ////                            for (int i = 1; i < geo.getNumGeometries(); i++) { 
    262 ////                                    newPoly = newPoly.union(geo.getGeometryN(i)); 
    263 ////                            }                        
    264 ////                             
    265 ////                            newPoly.buffer(0.0); 
    266 ////                             
    267 ////                            //Geometry col = new GeometryCollection(geometries, new GeometryFactory()).buffer(0.0); 
    268 ////                            System.out.println("Converted to a "+FindGeoType(newPoly)+" that is "+(newPoly.isValid() ? "" : "not ")+"valid."); 
    269 ////                            this.geometry = new StrabonPolyhedron(newPoly, algorithm, maxPoints).geometry; 
    270 //                               
    271 //                              //System.out.println("Non valid " + FindGeoType(geo) + " found. (coordinates:"+geo.getCoordinates().length+")"); 
    272 //                              //geo = TopologyPreservingSimplifier.simplify(geo, 0.2); 
    273 //                              while (true) { 
    274 //                                      if (geo.getCoordinates().length > 300000) { 
    275 //                                              geo = TopologyPreservingSimplifier.simplify(geo, 0.1); 
    276 //                                              System.out.println("Simplified to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid (coordinates:"+geo.getCoordinates().length+")."); 
    277 //                                      } 
    278 //                                      geo = geo.buffer(0.0); 
    279 //                                      System.out.println("Buffered to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid (coordinates:"+geo.getCoordinates().length+")."); 
    280 //                                       
    281 //                                      if (geo.isValid() && (geo.getCoordinates().length < 300000)) 
    282 //                                              break; 
    283 //                              }                                                                
    284 //                               
    285 //                              this.geometry = new StrabonPolyhedron(geo, algorithm, maxPoints).geometry; 
    286 //                               
    287 //                              //System.out.println("Are the geometries the same? Answer: " + (geo.equals(this.geometry) ? "true" : "false")); 
    288 //                               
    289 //                      } else { 
    290                                 MultiPolygon mpoly = (MultiPolygon)geo; 
    291                                 ArrayList<Polygon> collection = new ArrayList<Polygon>(mpoly.getNumGeometries()); 
    292          
    293                                 for (int i = 0; i < mpoly.getNumGeometries(); i++) { 
    294                                         System.out.println("[1] " + mpoly.getNumGeometries()); 
    295                                         StrabonPolyhedron poly = new StrabonPolyhedron(mpoly.getGeometryN(i), algorithm, maxPoints); 
    296                                         System.out.println("[2] " + poly.geometry.getNumGeometries()); 
    297                                         for (int j = 0; j < poly.geometry.getNumGeometries(); j++) { 
    298                                                 collection.add((Polygon)poly.geometry.getGeometryN(j)); 
    299                                         } 
     251                        //                      if (!geo.isValid()) { 
     252                        ////                            System.out.println("Non valid " + FindGeoType(geo) + " found."); 
     253                        ////                            geo = geo.buffer(0.0); 
     254                        ////                             
     255                        ////                            Geometry[] geometries = new Geometry[geo.getNumGeometries()]; 
     256                        ////                            for (int i = 0; i < geo.getNumGeometries(); i++) { 
     257                        ////                                    boolean before = geo.getGeometryN(i).isValid(); 
     258                        ////                                    geometries[i] = geo.getGeometryN(i).buffer(0.0); 
     259                        ////                                    boolean after = geometries[i].isValid(); 
     260                        ////                                    //System.out.println("Geometry " + i + " was " + (before ? "" : "not ") + "valid and now it is " + (after ? "still " : "not ") + "valid."); 
     261                        ////                            }                        
     262                        ////                             
     263                        ////                            Geometry col = new GeometryCollection(geometries, new GeometryFactory()).buffer(0.0); 
     264                        ////                            System.out.println("Converted to a "+FindGeoType(col)+" that is "+(col.isValid() ? "" : "not ")+"valid."); 
     265                        ////                            this.geometry = new StrabonPolyhedron(col, algorithm, maxPoints).geometry; 
     266                        //                               
     267                        ////                            System.out.println("Non valid " + FindGeoType(geo) + " found."); 
     268                        ////                             
     269                        ////                            System.out.println("Number of geometries: " + geo.getNumGeometries()); 
     270                        ////                            MultiPolygon multipoly = (MultiPolygon)geo; 
     271                        ////                            Geometry newPoly = multipoly.getGeometryN(0); 
     272                        ////                             
     273                        ////                            for (int i = 1; i < geo.getNumGeometries(); i++) { 
     274                        ////                                    newPoly = newPoly.union(geo.getGeometryN(i)); 
     275                        ////                            }                        
     276                        ////                             
     277                        ////                            newPoly.buffer(0.0); 
     278                        ////                             
     279                        ////                            //Geometry col = new GeometryCollection(geometries, new GeometryFactory()).buffer(0.0); 
     280                        ////                            System.out.println("Converted to a "+FindGeoType(newPoly)+" that is "+(newPoly.isValid() ? "" : "not ")+"valid."); 
     281                        ////                            this.geometry = new StrabonPolyhedron(newPoly, algorithm, maxPoints).geometry; 
     282                        //                               
     283                        //                              //System.out.println("Non valid " + FindGeoType(geo) + " found. (coordinates:"+geo.getCoordinates().length+")"); 
     284                        //                              //geo = TopologyPreservingSimplifier.simplify(geo, 0.2); 
     285                        //                              while (true) { 
     286                        //                                      if (geo.getCoordinates().length > 300000) { 
     287                        //                                              geo = TopologyPreservingSimplifier.simplify(geo, 0.1); 
     288                        //                                              System.out.println("Simplified to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid (coordinates:"+geo.getCoordinates().length+")."); 
     289                        //                                      } 
     290                        //                                      geo = geo.buffer(0.0); 
     291                        //                                      System.out.println("Buffered to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid (coordinates:"+geo.getCoordinates().length+")."); 
     292                        //                                       
     293                        //                                      if (geo.isValid() && (geo.getCoordinates().length < 300000)) 
     294                        //                                              break; 
     295                        //                              }                                                                
     296                        //                               
     297                        //                              this.geometry = new StrabonPolyhedron(geo, algorithm, maxPoints).geometry; 
     298                        //                               
     299                        //                              //System.out.println("Are the geometries the same? Answer: " + (geo.equals(this.geometry) ? "true" : "false")); 
     300                        //                               
     301                        //                      } else { 
     302                        MultiPolygon mpoly = (MultiPolygon)geo; 
     303                        ArrayList<Polygon> collection = new ArrayList<Polygon>(mpoly.getNumGeometries()); 
     304 
     305                        for (int i = 0; i < mpoly.getNumGeometries(); i++) { 
     306                                System.out.println("[1] " + mpoly.getNumGeometries()); 
     307                                StrabonPolyhedron poly = new StrabonPolyhedron(mpoly.getGeometryN(i), algorithm, maxPoints); 
     308                                System.out.println("[2] " + poly.geometry.getNumGeometries()); 
     309                                for (int j = 0; j < poly.geometry.getNumGeometries(); j++) { 
     310                                        collection.add((Polygon)poly.geometry.getGeometryN(j)); 
    300311                                } 
    301          
    302                                 Polygon[] polycollection = new Polygon[collection.size()]; 
    303                                 int k = 0; 
    304                                 for (Polygon polygon : collection) { 
    305                                         polycollection[k] = polygon; 
    306                                         k++; 
    307                                         assert (!polygon.isEmpty()); 
     312                        } 
     313 
     314                        Polygon[] polycollection = new Polygon[collection.size()]; 
     315                        int k = 0; 
     316                        for (Polygon polygon : collection) { 
     317                                polycollection[k] = polygon; 
     318                                k++; 
     319                                assert (!polygon.isEmpty()); 
     320                        } 
     321                        this.geometry = new MultiPolygon(polycollection, new GeometryFactory()); 
     322                        //                      } 
     323                } else { 
     324                        //                      if (!geo.isValid()) { 
     325                        //                              System.out.println("Non valid " + FindGeoType(geo) + " found."); 
     326                        //                              geo = geo.buffer(0.0); 
     327                        //                              System.out.println("Converted to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid+."); 
     328                        //                              this.geometry = new StrabonPolyhedron(geo, algorithm, maxPoints).geometry; 
     329                        //                      } else { 
     330                        for (int i = 0; i < geo.getNumGeometries(); i++) { 
     331                                StrabonPolyhedron smallGeo = new StrabonPolyhedron(geo.getGeometryN(i), algorithm, maxPoints); 
     332 
     333                                if (this.geometry == null) { 
     334                                        this.geometry = smallGeo.geometry; 
     335                                } else { 
     336                                        this.geometry.union(smallGeo.geometry); 
    308337                                } 
    309                                 this.geometry = new MultiPolygon(polycollection, new GeometryFactory()); 
    310 //                      } 
    311                 } else { 
    312 //                      if (!geo.isValid()) { 
    313 //                              System.out.println("Non valid " + FindGeoType(geo) + " found."); 
    314 //                              geo = geo.buffer(0.0); 
    315 //                              System.out.println("Converted to a "+FindGeoType(geo)+" that is "+(geo.isValid() ? "" : "not ")+"valid+."); 
    316 //                              this.geometry = new StrabonPolyhedron(geo, algorithm, maxPoints).geometry; 
    317 //                      } else { 
    318                                 for (int i = 0; i < geo.getNumGeometries(); i++) { 
    319                                         StrabonPolyhedron smallGeo = new StrabonPolyhedron(geo.getGeometryN(i), algorithm, maxPoints); 
    320                                          
    321                                         if (this.geometry == null) { 
    322                                                 this.geometry = smallGeo.geometry; 
    323                                         } else { 
    324                                                 this.geometry.union(smallGeo.geometry); 
    325                                         } 
    326                                 } 
    327 //                      } 
     338                        } 
     339                        //                      } 
    328340                } 
    329341        } 
     
    331343        public static StrabonPolyhedron ParseBigPolyhedron(Geometry polygon, int algorithm, boolean horizontal, int maxPoints) throws Exception { 
    332344                assert (Polygon.class.isInstance(polygon) || (MultiPolygon.class.isInstance(polygon))); 
    333                  
     345 
    334346                if (polygon.getCoordinates().length > maxPoints) { 
    335 //                      if (polygon.isValid()){ 
    336 //                              System.out.println("Found big polyhedron. Coordinates: " + polygon.getCoordinates().length + " (valid="+polygon.isValid()+")."); 
    337 //                      } else { 
    338 //                              System.out.println("Found invalid big polyhedron. Coordinates: " + polygon.getCoordinates().length + "."); 
    339 //                              //IsValidOp err = new IsValidOp(polygon); 
    340 //                              //System.out.println("Validation error: " + err.getValidationError()); 
    341 //                              //new Point(new CoordinateArraySequence(new Coordinate[] {polygon.getCoordinates()[0]}), new GeometryFactory()); 
    342 //                              //polygon = polygon.union(onePoint); 
    343 //                              polygon = polygon.buffer(0.0); 
    344 //                              System.out.println("After conversion, coordinates: " + polygon.getCoordinates().length + " (valid="+polygon.isValid()+")."); 
    345 //                      } 
     347                        //                      if (polygon.isValid()){ 
     348                        //                              System.out.println("Found big polyhedron. Coordinates: " + polygon.getCoordinates().length + " (valid="+polygon.isValid()+")."); 
     349                        //                      } else { 
     350                        //                              System.out.println("Found invalid big polyhedron. Coordinates: " + polygon.getCoordinates().length + "."); 
     351                        //                              //IsValidOp err = new IsValidOp(polygon); 
     352                        //                              //System.out.println("Validation error: " + err.getValidationError()); 
     353                        //                              //new Point(new CoordinateArraySequence(new Coordinate[] {polygon.getCoordinates()[0]}), new GeometryFactory()); 
     354                        //                              //polygon = polygon.union(onePoint); 
     355                        //                              polygon = polygon.buffer(0.0); 
     356                        //                              System.out.println("After conversion, coordinates: " + polygon.getCoordinates().length + " (valid="+polygon.isValid()+")."); 
     357                        //                      } 
    346358                        double minx = Double.MAX_VALUE, miny = Double.MAX_VALUE,  
    347                                maxx = Double.MIN_VALUE, maxy = Double.MIN_VALUE; 
     359                                        maxx = Double.MIN_VALUE, maxy = Double.MIN_VALUE; 
    348360 
    349361                        Geometry bbox = polygon.getEnvelope(); 
     
    363375                                                        new Coordinate(minx,                                                                            horizontal ? maxy : (miny + (maxy-miny)/2)), 
    364376                                                        new Coordinate(minx,                                                                            miny)} 
    365                         ), new GeometryFactory()), null, new GeometryFactory()); 
     377                                        ), new GeometryFactory()), null, new GeometryFactory()); 
    366378 
    367379                        firsthalf.normalize(); 
    368                          
     380 
    369381                        Polygon secondhalf = (Polygon) bbox.difference(firsthalf); 
    370382                        secondhalf.normalize(); 
    371                          
    372 //                      double a = polygon.getArea(); 
    373 //                      double b = polygon.getEnvelope().getArea(); 
    374 //                      double c = firsthalf.getArea(); 
    375 //                      double d = bbox.difference(firsthalf).getArea(); 
    376 //                       
    377 //                      double e = b-c-d; 
    378 //                      double f = c-d; 
    379 //                       
    380 //                      double kk = firsthalf.difference(bbox).difference(firsthalf).getArea(); 
    381 //                       
    382 //                      boolean g = firsthalf.equals(bbox.difference(firsthalf)); 
    383 //                      boolean h = firsthalf.disjoint(bbox.difference(firsthalf)); 
    384 //                      boolean i = bbox.equals(firsthalf.union(bbox.difference(firsthalf))); 
    385 //                       
    386 //                      boolean j = firsthalf.intersects(polygon); 
    387 //                      boolean k = bbox.difference(firsthalf).intersects(polygon); 
    388                          
     383 
     384                        //                      double a = polygon.getArea(); 
     385                        //                      double b = polygon.getEnvelope().getArea(); 
     386                        //                      double c = firsthalf.getArea(); 
     387                        //                      double d = bbox.difference(firsthalf).getArea(); 
     388                        //                       
     389                        //                      double e = b-c-d; 
     390                        //                      double f = c-d; 
     391                        //                       
     392                        //                      double kk = firsthalf.difference(bbox).difference(firsthalf).getArea(); 
     393                        //                       
     394                        //                      boolean g = firsthalf.equals(bbox.difference(firsthalf)); 
     395                        //                      boolean h = firsthalf.disjoint(bbox.difference(firsthalf)); 
     396                        //                      boolean i = bbox.equals(firsthalf.union(bbox.difference(firsthalf))); 
     397                        //                       
     398                        //                      boolean j = firsthalf.intersects(polygon); 
     399                        //                      boolean k = bbox.difference(firsthalf).intersects(polygon); 
     400 
    389401                        Geometry A = polygon.intersection(firsthalf); 
    390402                        System.out.println("First half  : " + A.getCoordinates().length + " coordinates."); 
     
    395407                        StrabonPolyhedron polyA = ParseBigPolyhedron(A, algorithm, !horizontal, maxPoints);                      
    396408                        StrabonPolyhedron polyB = ParseBigPolyhedron(B, algorithm, !horizontal, maxPoints); 
    397                          
     409 
    398410                        return StrabonPolyhedron.quickUnion(polyA, polyB); 
    399411                } else { 
    400 System.out.println("Found small polyhedron. Coordinates: " + polygon.getCoordinates().length); 
     412                        System.out.println("Found small polyhedron. Coordinates: " + polygon.getCoordinates().length); 
    401413                        return new StrabonPolyhedron(polygon, algorithm, maxPoints); 
    402414                } 
     
    404416 
    405417        public StrabonPolyhedron(Polygon polygon, int algorithm, int maxPoints) throws Exception { 
    406 //              if (!polygon.isSimple()) 
    407 //                      throw new Exception( 
    408 //                      "The polygon is not simple. Only simple polygons are supported"); 
     418                //              if (!polygon.isSimple()) 
     419                //                      throw new Exception( 
     420                //                      "The polygon is not simple. Only simple polygons are supported"); 
    409421 
    410422                Coordinate[] coordinates = polygon.getCoordinates(); 
    411                  
     423 
    412424                if (coordinates.length > maxPoints) { 
    413425                        this.geometry = ParseBigPolyhedron(polygon, algorithm, true, maxPoints).geometry; 
    414426                        return; 
    415427                }                
    416                  
     428 
    417429                int distinctCoordinates = 0; 
    418 boolean fix = false; 
     430                boolean fix = false; 
    419431                for (int i = 0; i <= coordinates.length - 1; i++) { 
    420432                        Coordinate c1 = coordinates[i]; 
    421                          
     433 
    422434                        if (i == (coordinates.length - 1)) { 
    423435                                // eimaste sto teleutaio simeio 
     
    429441                                } else  
    430442                                        if ((c1.x == coordinates[i-1].x) && (c1.y == coordinates[i-1].y)) { 
    431                                         //einai to idio me to proigoumeno opote den kanoume tipota giati 
    432                                         //exoun hdh auksithei ta dinstinct 
    433                                 } else {                                 
    434                                         // den einai to idio me to proigoumeno opote auksise ta distinct 
    435                                         distinctCoordinates++; 
    436                                 } 
     443                                                //einai to idio me to proigoumeno opote den kanoume tipota giati 
     444                                                //exoun hdh auksithei ta dinstinct 
     445                                        } else {                                 
     446                                                // den einai to idio me to proigoumeno opote auksise ta distinct 
     447                                                distinctCoordinates++; 
     448                                        } 
    437449                                continue; 
    438450                        }  
    439                          
     451 
    440452                        Coordinate c2 = coordinates[i+1]; 
    441                          
     453 
    442454                        if ((c1.x != c2.x) || (c1.y != c2.y)) { 
    443455                                distinctCoordinates++; 
    444456                        } 
    445457                } 
    446                  
     458 
    447459                //System.out.println("---\n---\n---\n---\n---\n"); 
    448460                //System.out.println("--- Coordinates.length   = " + coordinates.length); 
    449461                //System.out.println("--- Distinct coordinates = " + distinctCoordinates); 
    450462                //System.out.println("---\n---\n---\n---\n---\n"); 
    451                  
     463 
    452464                // cgal wants counter clockwise order 
    453465                //double[][] c = new double[coordinates.length - 1][2]; 
     
    457469                        Coordinate c1 = coordinates[i]; 
    458470                        Coordinate c2 = coordinates[i+1]; 
    459                          
     471 
    460472                        if ((c1.x != c2.x) || (c1.y != c2.y)) { 
    461473                                c[counter][0] = c1.x; 
     
    464476                        }                        
    465477                } 
    466                  
     478 
    467479                if (fix) { 
    468480                        c[distinctCoordinates-1][0] = coordinates[coordinates.length-1].x; 
    469481                        c[distinctCoordinates-1][1] = coordinates[coordinates.length-1].y; 
    470482                } 
    471                  
     483 
    472484                //System.out.println("--- Counter              = " + counter); 
    473485                //System.out.println("---\n---\n---\n---\n---\n"); 
    474                  
    475 //              BufferedWriter bww = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/cfunction.dat"))); 
    476 //              BufferedWriter bw2 = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/original.dat"))); 
    477 //              bww.write("void make_polygon(Polygon_2& polygon) {"); 
    478 //              for (int i = 0; i < coordinates.length - 1; i++) { 
    479 //                      Coordinate coordinate = coordinates[i]; 
    480 //                      bww.write("\tpolygon.push_back(Point_2("); 
    481 //                      bww.write(new Double(coordinate.x).toString()); 
    482 //                      bww.write(","); 
    483 //                      bww.write(new Double(coordinate.y).toString()); 
    484 //                      bww.write("));\n"); 
    485 //                       
    486 //                      bw2.write(new Double(coordinate.x).toString()); 
    487 //                      bw2.write(" "); 
    488 //                      bw2.write(new Double(coordinate.y).toString()); 
    489 //                      bw2.write("\n"); 
    490 //              } 
    491 //              bww.write("}\n"); 
    492 //              bww.flush(); 
    493 //              bww.close(); 
    494 //               
    495 //              bw2.flush(); 
    496 //              bw2.close(); 
     486 
     487                //              BufferedWriter bww = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/cfunction.dat"))); 
     488                //              BufferedWriter bw2 = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/original.dat"))); 
     489                //              bww.write("void make_polygon(Polygon_2& polygon) {"); 
     490                //              for (int i = 0; i < coordinates.length - 1; i++) { 
     491                //                      Coordinate coordinate = coordinates[i]; 
     492                //                      bww.write("\tpolygon.push_back(Point_2("); 
     493                //                      bww.write(new Double(coordinate.x).toString()); 
     494                //                      bww.write(","); 
     495                //                      bww.write(new Double(coordinate.y).toString()); 
     496                //                      bww.write("));\n"); 
     497                //                       
     498                //                      bw2.write(new Double(coordinate.x).toString()); 
     499                //                      bw2.write(" "); 
     500                //                      bw2.write(new Double(coordinate.y).toString()); 
     501                //                      bw2.write("\n"); 
     502                //              } 
     503                //              bww.write("}\n"); 
     504                //              bww.flush(); 
     505                //              bww.close(); 
     506                //               
     507                //              bw2.flush(); 
     508                //              bw2.close(); 
    497509 
    498510                double start = System.nanoTime(); 
    499 //              double[][][] convexified = Polyhedron.ConvexifyPolygon(c, algorithm); 
     511                //              double[][][] convexified = Polyhedron.ConvexifyPolygon(c, algorithm); 
    500512                double[][][] convexified = new double[1][2][3];          
    501                  
    502 //              if (convexified == null) { 
    503 //                      throw new ParseGeometryException("Invalid geometry. Only simple geometries are supported."); 
    504 //              } 
    505                  
     513 
     514                //              if (convexified == null) { 
     515                //                      throw new ParseGeometryException("Invalid geometry. Only simple geometries are supported."); 
     516                //              } 
     517 
    506518                System.out.println("ConvexifyTime " + (System.nanoTime()-start)); 
    507519 
     
    509521                double min = Double.MAX_VALUE; 
    510522                double max = Double.MIN_VALUE; 
    511                          
     523 
    512524                for (int i = 0; i < convexified.length; i++) { 
    513525                        double[][] convexCoordinates = convexified[i]; 
     
    518530                                        min = convexCoordinates[j][0]; 
    519531                        } 
    520                  
    521                 } 
    522                                  
    523 //              String gnuPlotScript = ""; 
    524 //               
    525 //              for (int i = 0; i < convexified.length; i++) { 
    526 //                      double[][] convexCoordinates = convexified[i]; 
    527 //                      sizes[convexCoordinates.length]++; 
    528 //                       
    529 //                      BufferedWriter bw = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/data-" + i + ".dat"))); 
    530 //                      bw2 = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/script-" + i + ".gnuplot"))); 
    531 //                      for (int j = 0; j < convexCoordinates.length; j++) { 
    532 //                              bw.write(new Double(convexCoordinates[j][0]).toString()); 
    533 //                              bw.write(" "); 
    534 //                              bw.write(new Double(convexCoordinates[j][1]).toString()); 
    535 //                              bw.write("\n"); 
    536 // 
    537 //                      } 
    538 //                      bw.flush(); 
    539 //                      bw.close(); 
    540 //                       
    541 //                      gnuPlotScript += "'data-" + i + ".dat' with lines,"; 
    542 //                       
    543 //                      bw2.write("set terminal postscript eps color\n"); 
    544 //                      bw2.write("set out '/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/geo-"+i+".eps'\n"); 
    545 //                      bw2.write("set key bmargin left horizontal Right noreverse enhanced autotitles box linetype -1 linewidth 1.000\n"); 
    546 //                      bw2.write("plot ["+0.95*min+":"+1.05*max+"] 'data-" + i +".dat' with lines, 'original.dat' with lines\n"); 
    547 //                      bw2.flush(); 
    548 //                      bw2.close(); 
    549 //              } 
    550 //                       
    551 //              gnuPlotScript = "plot ["+0.95*min+":"+1.05*max+"] " + gnuPlotScript.substring(0, gnuPlotScript.length()-1); 
    552 //              gnuPlotScript = "set terminal postscript eps color\n" + 
    553 //                                              "set out '/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/all.eps'\n" + 
    554 //                                              "set key bmargin left horizontal Right noreverse enhanced autotitles box linetype -1 linewidth 1.000\n" +  
    555 //                                              gnuPlotScript; 
    556 //               
    557 //              BufferedWriter bw = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/script-all.gnuplot"))); 
    558 //              bw.write(gnuPlotScript); 
    559 //              bw.flush(); 
    560 //              bw.close(); 
    561 //               
    562 //              for (int i = 0; i < convexified.length; i++) { 
    563 //                      Runtime.getRuntime().exec("gnuplot /home/kkyzir/Desktop/Spatial\\ data/ssg4env/geometries/gnuplot/script-"+i+".gnuplot"); 
    564 //              } 
    565 //               
    566 //              Runtime.getRuntime().exec("gnuplot /home/kkyzir/Desktop/Spatial\\ data/ssg4env/geometries/gnuplot/script-all.gnuplot"); 
    567 //               
    568                  
     532 
     533                } 
     534 
     535                //              String gnuPlotScript = ""; 
     536                //               
     537                //              for (int i = 0; i < convexified.length; i++) { 
     538                //                      double[][] convexCoordinates = convexified[i]; 
     539                //                      sizes[convexCoordinates.length]++; 
     540                //                       
     541                //                      BufferedWriter bw = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/data-" + i + ".dat"))); 
     542                //                      bw2 = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/script-" + i + ".gnuplot"))); 
     543                //                      for (int j = 0; j < convexCoordinates.length; j++) { 
     544                //                              bw.write(new Double(convexCoordinates[j][0]).toString()); 
     545                //                              bw.write(" "); 
     546                //                              bw.write(new Double(convexCoordinates[j][1]).toString()); 
     547                //                              bw.write("\n"); 
     548                // 
     549                //                      } 
     550                //                      bw.flush(); 
     551                //                      bw.close(); 
     552                //                       
     553                //                      gnuPlotScript += "'data-" + i + ".dat' with lines,"; 
     554                //                       
     555                //                      bw2.write("set terminal postscript eps color\n"); 
     556                //                      bw2.write("set out '/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/geo-"+i+".eps'\n"); 
     557                //                      bw2.write("set key bmargin left horizontal Right noreverse enhanced autotitles box linetype -1 linewidth 1.000\n"); 
     558                //                      bw2.write("plot ["+0.95*min+":"+1.05*max+"] 'data-" + i +".dat' with lines, 'original.dat' with lines\n"); 
     559                //                      bw2.flush(); 
     560                //                      bw2.close(); 
     561                //              } 
     562                //                       
     563                //              gnuPlotScript = "plot ["+0.95*min+":"+1.05*max+"] " + gnuPlotScript.substring(0, gnuPlotScript.length()-1); 
     564                //              gnuPlotScript = "set terminal postscript eps color\n" + 
     565                //                                              "set out '/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/all.eps'\n" + 
     566                //                                              "set key bmargin left horizontal Right noreverse enhanced autotitles box linetype -1 linewidth 1.000\n" +  
     567                //                                              gnuPlotScript; 
     568                //               
     569                //              BufferedWriter bw = new BufferedWriter(new FileWriter(new File("/home/kkyzir/Desktop/Spatial data/ssg4env/geometries/gnuplot/script-all.gnuplot"))); 
     570                //              bw.write(gnuPlotScript); 
     571                //              bw.flush(); 
     572                //              bw.close(); 
     573                //               
     574                //              for (int i = 0; i < convexified.length; i++) { 
     575                //                      Runtime.getRuntime().exec("gnuplot /home/kkyzir/Desktop/Spatial\\ data/ssg4env/geometries/gnuplot/script-"+i+".gnuplot"); 
     576                //              } 
     577                //               
     578                //              Runtime.getRuntime().exec("gnuplot /home/kkyzir/Desktop/Spatial\\ data/ssg4env/geometries/gnuplot/script-all.gnuplot"); 
     579                //               
     580 
    569581                //Geometry[] collection = new Geometry[convexified.length]; 
    570582                Polygon[] collection = new Polygon[convexified.length]; 
     
    605617 
    606618        public StrabonPolyhedron(String geometry) throws Exception { 
    607         if (geometry.startsWith("POINT") ||  
    608                         geometry.startsWith("LINESTRING") ||  
    609                         geometry.startsWith("POLYGON") ||  
    610                         geometry.startsWith("MULTIPOINT") ||  
    611                         geometry.startsWith("MULTILINESTRING") ||  
    612                         geometry.startsWith("MULTIPOLYGON") ||  
    613                         geometry.startsWith("GEOMETRYCOLLECTION")) { 
    614                 Geometry geo = new WKTReader().read(geometry); 
    615                 this.geometry = new StrabonPolyhedron(geo).geometry; 
    616         } else { 
    617                 //Polyhedron polyhedron = new Polyhedron(geometry); 
    618                 //String polyhedronWKT = polyhedron.toWKT(); 
    619                 //WKTReader reader = new WKTReader(); 
    620                 //Geometry geo = reader.read(polyhedronWKT); 
    621                 // 
    622                 //if (!EnableConstraintRepresentation) { 
    623                 //      this.geometry = geo.union(geo); 
    624                 //} 
    625         } 
    626 } 
    627          
     619                int geomSRID = 4326; 
     620                if(geometry.contains(";")) 
     621                { 
     622                        int whereToCut = geometry.lastIndexOf('/'); 
     623                        geomSRID = Integer.parseInt(geometry.substring(whereToCut+1)); 
     624                        whereToCut = geometry.indexOf(';'); 
     625                        geometry.substring(0,whereToCut); 
     626                } 
     627                if (geometry.startsWith("POINT") ||  
     628                                geometry.startsWith("LINESTRING") ||  
     629                                geometry.startsWith("POLYGON") ||  
     630                                geometry.startsWith("MULTIPOINT") ||  
     631                                geometry.startsWith("MULTILINESTRING") ||  
     632                                geometry.startsWith("MULTIPOLYGON") ||  
     633                                geometry.startsWith("GEOMETRYCOLLECTION")) { 
     634                        Geometry geo = new WKTReader().read(geometry); 
     635                        this.geometry = new StrabonPolyhedron(geo).geometry; 
     636                        //Default  
     637                        this.geometry.setSRID(geomSRID); 
     638                } else { 
     639                        //Polyhedron polyhedron = new Polyhedron(geometry); 
     640                        //String polyhedronWKT = polyhedron.toWKT(); 
     641                        //WKTReader reader = new WKTReader(); 
     642                        //Geometry geo = reader.read(polyhedronWKT); 
     643                        // 
     644                        //if (!EnableConstraintRepresentation) { 
     645                        //      this.geometry = geo.union(geo); 
     646                        //} 
     647                } 
     648        } 
     649 
    628650        public StrabonPolyhedron(String WKT, int algorithm) throws Exception { 
    629651                Geometry geo = new WKTReader().read(WKT); 
    630652                this.geometry = new StrabonPolyhedron(geo, algorithm).geometry; 
    631653        } 
    632          
     654 
    633655        public StrabonPolyhedron(String WKT, int algorithm, int maxPoints) throws Exception { 
    634656                Geometry geo = new WKTReader().read(WKT); 
     
    637659 
    638660        public StrabonPolyhedron(byte[] byteArray) throws ParseException { 
    639                  
     661 
    640662                this.geometry = new WKBReader().read(byteArray); 
    641 //              System.out.println(geometry.toString()+" "+geometry.getSRID()); 
     663                //              System.out.println(geometry.toString()+" "+geometry.getSRID()); 
     664        } 
     665 
     666        public StrabonPolyhedron(byte[] byteArray, int srid) throws ParseException { 
     667 
     668                this.geometry = new WKBReader().read(byteArray); 
     669                this.geometry.setSRID(srid); 
    642670        } 
    643671 
     
    646674                if (this.geometry.isEmpty()) 
    647675                        return ""; 
    648                  
     676 
    649677                if (!EnableConstraintRepresentation) { 
    650678                        return "Constraint representation is disabled."; 
    651679                } 
    652                  
     680 
    653681                //Polyhedron poly = new Polyhedron(this.geometry); 
    654682                //return poly.toConstraints(); 
     
    663691                return this.geometry.toText(); 
    664692        } 
    665          
     693 
    666694        public byte[] toWKB() { 
    667695                WKBWriter writer = new WKBWriter(); 
    668696                return writer.write(this.geometry);              
    669697        } 
    670          
     698 
    671699        public String toWKT() { 
    672700                WKTWriter writer = new WKTWriter(); 
     
    678706        } 
    679707 
     708 
     709 
    680710        public static StrabonPolyhedron union(StrabonPolyhedron A, StrabonPolyhedron B) throws Exception { 
    681711                StrabonPolyhedron poly = new StrabonPolyhedron(); 
    682                 poly.geometry = A.geometry.union(B.geometry); 
     712 
     713                int targetSRID = A.getGeometry().getSRID(); 
     714                int sourceSRID = B.getGeometry().getSRID(); 
     715                Geometry x = convertSRID(B.getGeometry(), sourceSRID, targetSRID); 
     716 
     717                poly.geometry = A.geometry.union(x); 
    683718 
    684719                return poly; 
    685720        } 
    686          
     721 
    687722        public static StrabonPolyhedron buffer(StrabonPolyhedron A, double B) throws Exception { 
    688723                StrabonPolyhedron poly = new StrabonPolyhedron(); 
    689724                poly.geometry = A.geometry.buffer(B); 
    690                  
     725 
    691726                return poly; 
    692727        } 
    693          
     728 
    694729        public static StrabonPolyhedron envelope(StrabonPolyhedron A) throws Exception { 
    695730                StrabonPolyhedron poly = new StrabonPolyhedron(); 
     
    698733                return poly; 
    699734        } 
    700          
     735 
    701736        public static StrabonPolyhedron convexHull(StrabonPolyhedron A) throws Exception { 
    702737                StrabonPolyhedron poly = new StrabonPolyhedron(); 
     
    705740                return poly; 
    706741        } 
    707          
     742 
    708743        public static StrabonPolyhedron boundary(StrabonPolyhedron A) throws Exception { 
    709744                StrabonPolyhedron poly = new StrabonPolyhedron(); 
     
    712747                return poly; 
    713748        } 
    714          
     749 
    715750        public static StrabonPolyhedron intersection(StrabonPolyhedron A, StrabonPolyhedron B) throws Exception { 
    716                 Geometry geo = A.geometry.intersection(B.geometry); 
    717                  
     751 
     752                int targetSRID = A.getGeometry().getSRID(); 
     753                int sourceSRID = B.getGeometry().getSRID(); 
     754                Geometry x = convertSRID(B.getGeometry(), sourceSRID, targetSRID); 
     755                Geometry geo = A.geometry.intersection(x); 
     756 
    718757                return new StrabonPolyhedron(geo); 
    719758        } 
     
    721760        public static StrabonPolyhedron difference(StrabonPolyhedron A, StrabonPolyhedron B) throws Exception { 
    722761                StrabonPolyhedron poly = new StrabonPolyhedron(); 
    723                 poly.geometry = A.geometry.difference(B.geometry); 
     762 
     763                int targetSRID = A.getGeometry().getSRID(); 
     764                int sourceSRID = B.getGeometry().getSRID(); 
     765                Geometry x = convertSRID(B.getGeometry(), sourceSRID, targetSRID); 
     766 
     767                poly.geometry = A.geometry.difference(x); 
    724768 
    725769                return poly; 
    726770        } 
    727          
     771 
    728772        public static StrabonPolyhedron symDifference(StrabonPolyhedron A, StrabonPolyhedron B) throws Exception { 
    729773                StrabonPolyhedron poly = new StrabonPolyhedron(); 
    730                 poly.geometry = A.geometry.symDifference(B.geometry); 
     774                int targetSRID = A.getGeometry().getSRID(); 
     775                int sourceSRID = B.getGeometry().getSRID(); 
     776                Geometry x = convertSRID(B.getGeometry(), sourceSRID, targetSRID); 
     777                poly.geometry = A.geometry.symDifference(x); 
    731778 
    732779                return poly; 
    733780        } 
    734          
     781 
    735782        public static double area(StrabonPolyhedron A) throws Exception { 
    736783                return A.geometry.getArea(); 
    737784        } 
    738          
     785 
    739786        public static double distance(StrabonPolyhedron A, StrabonPolyhedron B) throws Exception { 
    740                 return A.geometry.distance(B.geometry); 
    741         } 
    742          
     787                int targetSRID = A.getGeometry().getSRID(); 
     788                int sourceSRID = B.getGeometry().getSRID(); 
     789                Geometry x = convertSRID(B.getGeometry(), sourceSRID, targetSRID); 
     790                return A.geometry.distance(x); 
     791        } 
     792 
    743793        public static StrabonPolyhedron project(StrabonPolyhedron A, int[] dims) throws Exception { 
    744794                StrabonPolyhedron poly = new StrabonPolyhedron(); 
     
    761811                System.out.println("Merging polyhedrons: A.coordinates=" + A.getGeometry().getCoordinates().length +  
    762812                                ", B.coordinates=" + B.getGeometry().getCoordinates().length); 
    763                  
     813 
    764814                StrabonPolyhedron poly = new StrabonPolyhedron(); 
    765815                int polygons = 0; 
     
    767817                        polygons++; 
    768818                } else if (MultiPolygon.class.isInstance(A.geometry)) { 
    769                                 polygons += ((MultiPolygon)(A.geometry)).getNumGeometries(); 
     819                        polygons += ((MultiPolygon)(A.geometry)).getNumGeometries(); 
    770820                } 
    771821                if (Polygon.class.isInstance(B.geometry)) { 
     
    802852                        } 
    803853                } 
    804                  
     854 
    805855                poly.geometry = new MultiPolygon(polys, new GeometryFactory()); 
    806856 
     
    808858        } 
    809859 
    810          
     860 
    811861        public StrabonPolyhedron getBuffer(double distance) throws Exception { 
    812862                Geometry geo = this.geometry.buffer(distance); 
     
    834884                return this.geometry; 
    835885        } 
    836          
     886 
    837887        public int getNumPoints() { 
    838888                return this.geometry.getNumPoints(); 
    839889        } 
    840          
     890 
    841891        private static String FindGeoType(Geometry geo) { 
    842892                return  
    843                 Point.class.isInstance(geo) ? "Point" : 
    844                         MultiPoint.class.isInstance(geo) ? "MultiPoint" : 
    845                                 LineString.class.isInstance(geo) ? "LineString" : 
    846                                         MultiLineString.class.isInstance(geo) ? "MultiLineString" : 
    847                                                 Polygon.class.isInstance(geo) ? "Polygon" : 
    848                                                         MultiPolygon.class.isInstance(geo) ? "MultiPolygon" : 
    849                                                                 GeometryCollection.class.isInstance(geo) ? "GeometryCollection" :  
    850                                                                         "Unknown"; 
     893                                Point.class.isInstance(geo) ? "Point" : 
     894                                        MultiPoint.class.isInstance(geo) ? "MultiPoint" : 
     895                                                LineString.class.isInstance(geo) ? "LineString" : 
     896                                                        MultiLineString.class.isInstance(geo) ? "MultiLineString" : 
     897                                                                Polygon.class.isInstance(geo) ? "Polygon" : 
     898                                                                        MultiPolygon.class.isInstance(geo) ? "MultiPolygon" : 
     899                                                                                GeometryCollection.class.isInstance(geo) ? "GeometryCollection" :  
     900                                                                                        "Unknown"; 
    851901        } 
    852902 
     
    861911                        try {                    
    862912                                String WKT = "POLYGON((" 
    863                                         + "342164.38954080583 5536425.686612717 , " 
    864                                         + "341626.21626698505 5536449.481769281 , " 
    865                                         + "341533.2278808594  5536525.216353727 , " 
    866                                         + "341233.98619135865 5536475.226529011 , " 
    867                                         + "341127.21075357014 5536983.653040268 , " 
    868                                         + "341215.02899532224 5537144.780243294 , " 
    869                                         + "340955.95747845445 5537799.537709246 , " 
    870                                         + "343211.19068847306 5537879.8934287615, " 
    871                                         + "343442.00065602345 5537324.533655008 , " 
    872                                         + "343314.06638177147 5537172.864526819 , " 
    873                                         + "343297.4180221379  5536922.705445975 , " 
    874                                         + "342969.57149877446 5536768.366861146 , " 
    875                                         + "342464.2661603174  5536951.549574836 , " 
    876                                         + "342296.77657097764 5536842.341803761 , " 
    877                                         + "342222.48151387094 5536641.402704332 , " 
    878                                         + "342286.9145411997  5536458.319970291 , " 
    879                                         + "342164.38954080583 5536425.686612717" + "))"; 
     913                                                + "342164.38954080583 5536425.686612717 , " 
     914                                                + "341626.21626698505 5536449.481769281 , " 
     915                                                + "341533.2278808594  5536525.216353727 , " 
     916                                                + "341233.98619135865 5536475.226529011 , " 
     917                                                + "341127.21075357014 5536983.653040268 , " 
     918                                                + "341215.02899532224 5537144.780243294 , " 
     919                                                + "340955.95747845445 5537799.537709246 , " 
     920                                                + "343211.19068847306 5537879.8934287615, " 
     921                                                + "343442.00065602345 5537324.533655008 , " 
     922                                                + "343314.06638177147 5537172.864526819 , " 
     923                                                + "343297.4180221379  5536922.705445975 , " 
     924                                                + "342969.57149877446 5536768.366861146 , " 
     925                                                + "342464.2661603174  5536951.549574836 , " 
     926                                                + "342296.77657097764 5536842.341803761 , " 
     927                                                + "342222.48151387094 5536641.402704332 , " 
     928                                                + "342286.9145411997  5536458.319970291 , " 
     929                                                + "342164.38954080583 5536425.686612717" + "))"; 
    880930 
    881931                                start = System.nanoTime(); 
     
    921971                return this.toWKT(); 
    922972        } 
    923          
     973 
    924974        @Override 
    925975        public boolean equals(Object other) { 
     
    931981                                return true; 
    932982                        } 
    933                          
     983 
    934984                } 
    935985                return false; 
  • evaluation/src/main/java/org/openrdf/query/algebra/evaluation/iterator/StSPARQLGroupIterator.java

    r44 r47  
    347347                                ValueExpr expr = spatialAggregates.get(name); 
    348348 
    349                                 StrabonPolyhedron poly = null; 
    350349                                Value val = null; 
    351                                 //LiteralImpl lit  
    352350                                try { 
    353351                                        val = evaluateConstruct(expr, this.prototype); 
     
    356354                                } 
    357355                                if (val != null) { 
    358                                         Literal wkt = new LiteralImpl(val.toString(),new URIImpl(StrabonPolyhedron.ogcGeometry)); 
    359                                         sol.setBinding(name,wkt); 
     356                                        if(val instanceof StrabonPolyhedron) 
     357                                        { 
     358                                                String label = val.toString()+";http://www.opengis.net/def/crs/EPSG/0/"+((StrabonPolyhedron)val).getGeometry().getSRID(); 
     359                                                Literal wkt = new LiteralImpl(label,new URIImpl(StrabonPolyhedron.ogcGeometry)); 
     360                                                sol.setBinding(name,wkt); 
     361                                        } 
     362                                        else 
     363                                        { 
     364                                                sol.setBinding(name, val); 
     365                                        } 
    360366                                } 
    361367 
     
    402408                                                leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    403409                                                rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    404  
    405                                                 int leftSRID = leftArg.getGeometry().getSRID(); 
    406                                                 int rightSRID = rightArg.getGeometry().getSRID(); 
    407                                                 if(leftSRID != rightSRID) 
    408                                                 { 
    409                                                         //XXX Will have to express the second argument in the SRID of the first 
    410                                                         rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    411                                                 } 
    412410                                                return StrabonPolyhedron.union(leftArg, rightArg); 
    413411                                        } 
     
    445443                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    446444                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    447                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    448                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    449                                         if(leftSRID != rightSRID) 
    450                                         { 
    451                                                 //XXX Will have to express the second argument in the SRID of the first 
    452                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    453                                         } 
    454445                                        return StrabonPolyhedron.intersection(leftArg, rightArg); 
    455446                                } 
     
    458449                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    459450                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    460                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    461                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    462                                         if(leftSRID != rightSRID) 
    463                                         { 
    464                                                 //XXX Will have to express the second argument in the SRID of the first 
    465                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    466                                         } 
    467451                                        return StrabonPolyhedron.difference(leftArg, rightArg); 
    468452                                } 
     
    471455                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    472456                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    473                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    474                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    475                                         if(leftSRID != rightSRID) 
    476                                         { 
    477                                                 //XXX Will have to express the second argument in the SRID of the first 
    478                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    479                                         } 
    480457                                        return StrabonPolyhedron.symDifference(leftArg, rightArg); 
    481458                                } 
     
    490467                                        leftArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(0),prototype); 
    491468                                        rightArg = (StrabonPolyhedron) evaluateConstruct(((FunctionCall) expr).getArgs().get(1),prototype); 
    492                                         int leftSRID = leftArg.getGeometry().getSRID(); 
    493                                         int rightSRID = rightArg.getGeometry().getSRID(); 
    494                                         if(leftSRID != rightSRID) 
    495                                         { 
    496                                                 //XXX Will have to express the second argument in the SRID of the first 
    497                                                 rightArg.setGeometry(StrabonPolyhedron.convertSRID(rightArg.getGeometry(),leftSRID, rightSRID)); 
    498                                         } 
    499469                                        return vf.createLiteral(""+StrabonPolyhedron.distance(leftArg, rightArg), XMLSchema.DOUBLE); 
    500470                                } 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/GeneralDBValueFactory.java

    r5 r47  
    370370         */ 
    371371 
    372         public GeneralDBPolyhedron getRdbmsPolyhedron(Number num, String datatype, byte[] pointSet)  { 
     372        public GeneralDBPolyhedron getRdbmsPolyhedron(Number num, String datatype, byte[] wkb, int srid)  { 
    373373 
    374374                Number id = ids.idOf(num); 
    375375                try { 
    376                         return new GeneralDBPolyhedron(id, literals.getIdVersion(), vf.createURI(datatype), pointSet); 
     376                        return new GeneralDBPolyhedron(id, literals.getIdVersion(), vf.createURI(datatype), wkb, srid); 
    377377                } catch (IOException e) { 
    378378                        e.printStackTrace(); 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/evaluation/GeneralDBEvaluation.java

    r46 r47  
    374374                                if(function instanceof AboveFunc) 
    375375                                { 
    376                                         funcResult = leftGeom.getEnvelopeInternal().getMinY() > rightGeom.getEnvelopeInternal().getMaxY(); 
     376                                        int targetSRID = leftGeom.getSRID(); 
     377                                        int sourceSRID = rightGeom.getSRID(); 
     378                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     379                                        funcResult = leftGeom.getEnvelopeInternal().getMinY() > rightConverted.getEnvelopeInternal().getMaxY(); 
    377380                                } 
    378381                                else if(function instanceof AnyInteractFunc) 
    379382                                { 
    380                                         funcResult = leftGeom.intersects(rightGeom); 
     383                                        int targetSRID = leftGeom.getSRID(); 
     384                                        int sourceSRID = rightGeom.getSRID(); 
     385                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     386                                        funcResult = leftGeom.intersects(rightConverted); 
    381387                                } 
    382388                                else if(function instanceof BelowFunc) 
    383389                                { 
    384                                         funcResult = leftGeom.getEnvelopeInternal().getMaxY() < rightGeom.getEnvelopeInternal().getMinY(); 
     390                                        int targetSRID = leftGeom.getSRID(); 
     391                                        int sourceSRID = rightGeom.getSRID(); 
     392                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     393                                        funcResult = leftGeom.getEnvelopeInternal().getMaxY() < rightConverted.getEnvelopeInternal().getMinY(); 
    385394                                } 
    386395                                else if(function instanceof ContainsFunc) 
    387396                                { 
    388                                         funcResult = leftGeom.contains(rightGeom); 
     397                                        int targetSRID = leftGeom.getSRID(); 
     398                                        int sourceSRID = rightGeom.getSRID(); 
     399                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     400                                        funcResult = leftGeom.contains(rightConverted); 
    389401                                } 
    390402                                else if(function instanceof CoveredByFunc) 
    391403                                { 
    392                                         funcResult = leftGeom.coveredBy(rightGeom); 
     404                                        int targetSRID = leftGeom.getSRID(); 
     405                                        int sourceSRID = rightGeom.getSRID(); 
     406                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     407                                        funcResult = leftGeom.coveredBy(rightConverted); 
    393408                                } 
    394409                                else if(function instanceof CoversFunc) 
    395410                                { 
    396                                         funcResult = leftGeom.covers(rightGeom); 
     411                                        int targetSRID = leftGeom.getSRID(); 
     412                                        int sourceSRID = rightGeom.getSRID(); 
     413                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     414                                        funcResult = leftGeom.covers(rightConverted); 
    397415                                } 
    398416                                else if(function instanceof DisjointFunc) 
    399417                                { 
    400                                         funcResult = leftGeom.disjoint(rightGeom); 
     418                                        int targetSRID = leftGeom.getSRID(); 
     419                                        int sourceSRID = rightGeom.getSRID(); 
     420                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     421                                        funcResult = leftGeom.disjoint(rightConverted); 
    401422                                } 
    402423                                else if(function instanceof EqualsFunc) 
    403424                                { 
    404                                         funcResult = leftGeom.equals(rightGeom); 
     425                                        int targetSRID = leftGeom.getSRID(); 
     426                                        int sourceSRID = rightGeom.getSRID(); 
     427                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     428                                        funcResult = leftGeom.equals(rightConverted); 
    405429                                } 
    406430                                else if(function instanceof InsideFunc) 
    407431                                { 
    408                                         funcResult = leftGeom.within(rightGeom); 
     432                                        int targetSRID = leftGeom.getSRID(); 
     433                                        int sourceSRID = rightGeom.getSRID(); 
     434                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     435                                        funcResult = leftGeom.within(rightConverted); 
    409436                                } 
    410437                                else if(function instanceof LeftFunc) 
    411438                                { 
    412                                         funcResult = leftGeom.getEnvelopeInternal().getMaxX() < rightGeom.getEnvelopeInternal().getMinX(); 
     439                                        int targetSRID = leftGeom.getSRID(); 
     440                                        int sourceSRID = rightGeom.getSRID(); 
     441                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     442                                        funcResult = leftGeom.getEnvelopeInternal().getMaxX() < rightConverted.getEnvelopeInternal().getMinX(); 
    413443                                } 
    414444                                else if(function instanceof OverlapFunc) 
    415445                                { 
    416                                         funcResult = leftGeom.overlaps(rightGeom); 
     446                                        int targetSRID = leftGeom.getSRID(); 
     447                                        int sourceSRID = rightGeom.getSRID(); 
     448                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     449                                        //System.out.println(rightConverted.toString()); 
     450                                        funcResult = leftGeom.overlaps(rightConverted); 
    417451                                } 
    418452                                else if(function instanceof RightFunc) 
    419453                                { 
    420                                         funcResult = leftGeom.getEnvelopeInternal().getMinX() > rightGeom.getEnvelopeInternal().getMaxX(); 
    421  
     454                                        int targetSRID = leftGeom.getSRID(); 
     455                                        int sourceSRID = rightGeom.getSRID(); 
     456                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     457                                        funcResult = leftGeom.getEnvelopeInternal().getMinX() > rightConverted.getEnvelopeInternal().getMaxX(); 
    422458                                } 
    423459                                else if(function instanceof TouchFunc) 
    424460                                { 
    425                                         funcResult = leftGeom.touches(rightGeom); 
     461                                        int targetSRID = leftGeom.getSRID(); 
     462                                        int sourceSRID = rightGeom.getSRID(); 
     463                                        Geometry rightConverted = StrabonPolyhedron.convertSRID(rightGeom, sourceSRID, targetSRID); 
     464                                        funcResult = leftGeom.touches(rightConverted); 
    426465                                } 
    427466 
     
    452491                { 
    453492                        StrabonPolyhedron rightArg = ((GeneralDBPolyhedron) right).getPolyhedron(); 
    454  
    455                         return new StrabonPolyhedron(leftArg.getGeometry().union(rightArg.getGeometry())); 
     493                        return StrabonPolyhedron.union(leftArg, rightArg); 
    456494                } 
    457495                else if(function.getURI().equals(StrabonPolyhedron.buffer)) 
     
    460498                        { 
    461499                                LiteralImpl radius = (LiteralImpl) right; 
    462                                 return new StrabonPolyhedron(leftArg.getGeometry().buffer(radius.doubleValue())); 
     500                                return StrabonPolyhedron.buffer(leftArg,radius.doubleValue()); 
    463501                        } 
    464502                        else if(right instanceof RdbmsLiteral) 
    465503                        { 
    466504                                RdbmsLiteral radius = (RdbmsLiteral) right; 
    467                                 return new StrabonPolyhedron(leftArg.getGeometry().buffer(radius.doubleValue())); 
     505                                return StrabonPolyhedron.buffer(leftArg,radius.doubleValue()); 
    468506                        } 
    469507 
     
    471509                else if(function.getURI().equals(StrabonPolyhedron.envelope)) 
    472510                { 
    473                         return new StrabonPolyhedron(leftArg.getGeometry().getEnvelope()); 
     511                        return StrabonPolyhedron.envelope(leftArg); 
    474512                } 
    475513                else if(function.getURI().equals(StrabonPolyhedron.convexHull)) 
    476514                { 
    477                         return new StrabonPolyhedron(leftArg.getGeometry().convexHull()); 
     515                        return StrabonPolyhedron.convexHull(leftArg); 
    478516                } 
    479517                else if(function.getURI().equals(StrabonPolyhedron.boundary)) 
    480518                { 
    481                         return new StrabonPolyhedron(leftArg.getGeometry().getBoundary()); 
     519                        return StrabonPolyhedron.boundary(leftArg); 
    482520                } 
    483521                else if(function.getURI().equals(StrabonPolyhedron.intersection)) 
    484522                { 
    485523                        StrabonPolyhedron rightArg = ((GeneralDBPolyhedron) right).getPolyhedron(); 
    486                         return new StrabonPolyhedron(leftArg.getGeometry().intersection(rightArg.getGeometry())); 
     524                        return StrabonPolyhedron.intersection(leftArg, rightArg); 
    487525                } 
    488526                else if(function.getURI().equals(StrabonPolyhedron.difference)) 
    489527                { 
    490528                        StrabonPolyhedron rightArg = ((GeneralDBPolyhedron) right).getPolyhedron(); 
    491                         return new StrabonPolyhedron(leftArg.getGeometry().difference(rightArg.getGeometry())); 
     529                        return StrabonPolyhedron.difference(leftArg, rightArg);          
    492530                } 
    493531                else if(function.getURI().equals(StrabonPolyhedron.symDifference)) 
    494532                { 
    495533                        StrabonPolyhedron rightArg = ((GeneralDBPolyhedron) right).getPolyhedron(); 
    496                         return new StrabonPolyhedron(leftArg.getGeometry().symDifference(rightArg.getGeometry())); 
     534                        return StrabonPolyhedron.symDifference(leftArg, rightArg);               
    497535                } 
    498536                return null; 
  • generaldb/src/main/java/org/openrdf/sail/generaldb/model/GeneralDBPolyhedron.java

    r0 r47  
    1818         * CONSTRUCTOR 
    1919         */ 
    20         public GeneralDBPolyhedron(Number id, Integer version, URI datatype, byte[] polyhedron) throws IOException, ClassNotFoundException { 
     20        public GeneralDBPolyhedron(Number id, Integer version, URI datatype, byte[] polyhedron, int srid) throws IOException, ClassNotFoundException { 
    2121                super(id, version); 
    2222 
    2323                try { 
    24                         this.polyhedron = new StrabonPolyhedron(polyhedron); 
     24                        this.polyhedron = new StrabonPolyhedron(polyhedron, srid); 
    2525                } catch (ParseException e) { 
    2626 
  • monetdb/src/main/java/org/openrdf/sail/monetdb/iteration/MonetDBBindingIteration.java

    r0 r47  
    4747                        Blob labelBlob = rs.getBlob(index + 1); 
    4848                byte[] label = labelBlob.getBytes((long)1, (int)labelBlob.length()); 
    49  
    50                         return vf.getRdbmsPolyhedron(id, StrabonPolyhedron.ogcGeometry, label); 
     49                int srid = rs.getInt(index + 2); 
     50                        return vf.getRdbmsPolyhedron(id, StrabonPolyhedron.ogcGeometry, label, srid); 
    5151 
    5252                } 
     
    6464                Blob labelBlob = rs.getBlob(index + 1);  
    6565                byte[] label = labelBlob.getBytes((long)1, (int)labelBlob.length()); 
    66                 return vf.getRdbmsPolyhedron(114, StrabonPolyhedron.ogcGeometry, label); 
     66                int srid = rs.getInt(index + 2); 
     67                return vf.getRdbmsPolyhedron(114, StrabonPolyhedron.ogcGeometry, label, srid); 
    6768 
    6869        } 
  • postgis/src/main/java/org/openrdf/sail/postgis/iteration/PostGISBindingIteration.java

    r0 r47  
    4646                { 
    4747                        byte[] label = rs.getBytes(index + 1); 
    48  
    49                         return vf.getRdbmsPolyhedron(id, StrabonPolyhedron.ogcGeometry, label); 
     48                        int srid = rs.getInt(index + 2); 
     49                        return vf.getRdbmsPolyhedron(id, StrabonPolyhedron.ogcGeometry, label, srid); 
    5050 
    5151                } 
     
    6262                //Case of spatial constructs 
    6363                byte[] label = rs.getBytes(index + 1); 
    64                 return vf.getRdbmsPolyhedron(114, StrabonPolyhedron.ogcGeometry, label); 
     64                int srid = rs.getInt(index + 2); 
     65                return vf.getRdbmsPolyhedron(114, StrabonPolyhedron.ogcGeometry, label, srid); 
    6566 
    6667        } 
  • runtime/pom.xml

    r36 r47  
    159159                                <groupId>org.geotools</groupId> 
    160160                                <artifactId>gt-shapefile</artifactId> 
     161                        </dependency> 
     162                         
     163                        <dependency> 
     164                                <groupId>org.geotools</groupId> 
     165                                <artifactId>gt-opengis</artifactId> 
    161166                        </dependency> 
    162167 
  • runtime/src/main/java/eu/earthobservatory/runtime/generaldb/Strabon.java

    r27 r47  
    9292                //Setting up store 
    9393 
    94  
     94                //Used for the conversions taking place involving JTS + WGS84 (4326) 
     95                System.setProperty("org.geotools.referencing.forceXY", "true"); 
    9596                //our repository 
    9697                repo1 = new SailRepository(db_store); 
Note: See TracChangeset for help on using the changeset viewer.