Exemplo n.º 1
0
  /**
   * Create a new raster that contains all data we need for the transformation.
   *
   * @throws IllegalArgumentException
   */
  private AbstractRaster getSubRaster(
      ICRS srcCRS, AbstractRaster sourceRaster, Envelope dstEnvelope)
      throws TransformationException, IllegalArgumentException {
    Envelope dataEnv = dstEnvelope;
    if (srcCRS != null && !srcCRS.equals(getTargetCRS())) {

      GeometryTransformer srcTransf = new GeometryTransformer(srcCRS);

      // the envelope from which we need data
      Envelope workEnv = srcTransf.transform(dstEnvelope, getTargetCRS());

      Envelope dataEnvelope = sourceRaster.getEnvelope();
      // the envelope from which we have data
      Geometry dataEnvGeom = workEnv.getIntersection(dataEnvelope);
      if (dataEnvGeom == null) {
        LOG.debug("no intersection for " + sourceRaster + " and " + dstEnvelope);
        // todo create subclass of TransformationException
        throw new TransformationException("no source data found");
      }
      dataEnv = dataEnvGeom.getEnvelope();
    }

    AbstractRaster source;
    try {
      source = sourceRaster.getSubRaster(dataEnv);
    } catch (IndexOutOfBoundsException ex) {
      throw new TransformationException("no source data found");
    }
    // if ( LOG.isDebugEnabled() ) {
    // debugRasterFile( source );
    // }
    return source;
  }
Exemplo n.º 2
0
  @Override
  public <T> boolean evaluate(T obj, XPathEvaluator<T> xpathEvaluator)
      throws FilterEvaluationException {

    Expression param1 = getParam1();
    if (param1 != null) {
      for (TypedObjectNode paramValue : param1.evaluate(obj, xpathEvaluator)) {
        Geometry param1Value = checkGeometryOrNull(paramValue);
        if (param1Value != null) {
          Geometry transformedGeom = getCompatibleGeometry(param1Value, geometry);
          return transformedGeom.intersects(param1Value);
        }
      }
    } else if (obj instanceof Feature) {
      // handle the case where the property name is empty
      Feature f = (Feature) obj;
      for (Property prop : f.getProperties()) {
        if (prop.getValue() instanceof Geometry) {
          Geometry geom = (Geometry) prop.getValue();
          Geometry transformedGeom = getCompatibleGeometry(geometry, geom);
          if (transformedGeom.intersects(geometry)) {
            return true;
          }
        }
      }
      if (f.getExtraProperties() != null) {
        for (Property prop : f.getExtraProperties().getProperties()) {
          if (prop.getValue() instanceof Geometry) {
            Geometry geom = (Geometry) prop.getValue();
            Geometry transformedGeom = getCompatibleGeometry(geometry, geom);
            if (transformedGeom.intersects(geometry)) {
              return true;
            }
          }
        }
      }
    } else {
      LOG.warn("Evaluating Intersects on non-Feature object and property name not specified.");
    }
    return false;
  }
  @Override
  public List<String> performInsert(FeatureCollection fc, IDGenMode mode)
      throws FeatureStoreException {

    LOG.debug("performInsert()");

    Set<Geometry> geometries = new LinkedHashSet<Geometry>();
    Set<Feature> features = new LinkedHashSet<Feature>();
    Set<String> fids = new LinkedHashSet<String>();
    Set<String> gids = new LinkedHashSet<String>();
    for (Feature member : fc) {
      findFeaturesAndGeometries(member, geometries, features, fids, gids);
    }

    LOG.debug(features.size() + " features / " + geometries.size() + " geometries");

    for (FeatureInspector inspector : inspectors) {
      for (Feature f : features) {
        // TODO cope with inspectors that return a different instance
        inspector.inspect(f);
      }
    }

    long begin = System.currentTimeMillis();

    String fid = null;
    try {
      PreparedStatement blobInsertStmt = null;
      if (blobMapping != null) {
        switch (mode) {
          case GENERATE_NEW:
            {
              // TODO don't change incoming features / geometries
              for (Feature feature : features) {
                String newFid = "FEATURE_" + generateNewId();
                String oldFid = feature.getId();
                if (oldFid != null) {
                  fids.remove(oldFid);
                }
                fids.add(newFid);
                feature.setId(newFid);
              }
              for (Geometry geometry : geometries) {
                String newGid = "GEOMETRY_" + generateNewId();
                String oldGid = geometry.getId();
                if (oldGid != null) {
                  gids.remove(oldGid);
                }
                gids.add(newGid);
                geometry.setId(newGid);
              }
              break;
            }
          case REPLACE_DUPLICATE:
            {
              throw new FeatureStoreException("REPLACE_DUPLICATE is not available yet.");
            }
          case USE_EXISTING:
            {
              // TODO don't change incoming features / geometries
              for (Feature feature : features) {
                if (feature.getId() == null) {
                  String newFid = "FEATURE_" + generateNewId();
                  feature.setId(newFid);
                  fids.add(newFid);
                }
              }

              for (Geometry geometry : geometries) {
                if (geometry.getId() == null) {
                  String newGid = "GEOMETRY_" + generateNewId();
                  geometry.setId(newGid);
                  gids.add(newGid);
                }
              }
              break;
            }
        }
        StringBuilder sql = new StringBuilder("INSERT INTO ");
        sql.append(blobMapping.getTable());
        sql.append(" (");
        sql.append(blobMapping.getGMLIdColumn());
        sql.append(",");
        sql.append(blobMapping.getTypeColumn());
        sql.append(",");
        sql.append(blobMapping.getDataColumn());
        sql.append(",");
        sql.append(blobMapping.getBBoxColumn());
        sql.append(") VALUES(?,?,?,");
        sql.append(blobGeomConverter.getSetSnippet(null));
        sql.append(")");
        LOG.debug("Inserting: {}", sql);
        blobInsertStmt = conn.prepareStatement(sql.toString());
        for (Feature feature : features) {
          fid = feature.getId();
          if (blobInsertStmt != null) {
            insertFeatureBlob(blobInsertStmt, feature);
          }
          FeatureTypeMapping ftMapping = fs.getMapping(feature.getName());
          if (ftMapping != null) {
            throw new UnsupportedOperationException();
          }
          ICRS storageSrs = blobMapping.getCRS();
          bboxTracker.insert(feature, storageSrs);
        }
        if (blobInsertStmt != null) {
          blobInsertStmt.close();
        }
      } else {
        // pure relational mode
        List<FeatureRow> idAssignments = new ArrayList<FeatureRow>();
        InsertRowManager insertManager = new InsertRowManager(fs, conn, mode);
        for (Feature feature : features) {
          FeatureTypeMapping ftMapping = fs.getMapping(feature.getName());
          if (ftMapping == null) {
            throw new FeatureStoreException(
                "Cannot insert feature of type '"
                    + feature.getName()
                    + "'. No mapping defined and BLOB mode is off.");
          }
          idAssignments.add(insertManager.insertFeature(feature, ftMapping));
          Pair<TableName, GeometryMapping> mapping = ftMapping.getDefaultGeometryMapping();
          if (mapping != null) {
            ICRS storageSrs = mapping.second.getCRS();
            bboxTracker.insert(feature, storageSrs);
          }
        }
        if (insertManager.getDelayedRows() != 0) {
          String msg =
              "After insertion, "
                  + insertManager.getDelayedRows()
                  + " delayed rows left uninserted. Probably a cyclic key constraint blocks insertion.";
          throw new RuntimeException(msg);
        }
        // TODO why is this necessary?
        fids.clear();
        for (FeatureRow assignment : idAssignments) {
          fids.add(assignment.getNewId());
        }
      }
    } catch (Throwable t) {
      String msg = "Error inserting feature: " + t.getMessage();
      LOG.error(msg);
      LOG.trace("Stack trace:", t);
      throw new FeatureStoreException(msg, t);
    }

    long elapsed = System.currentTimeMillis() - begin;
    LOG.debug("Insertion of " + features.size() + " features: " + elapsed + " [ms]");
    return new ArrayList<String>(fids);
  }