/*
   * Adds a feature layer to the geopackage.
   */
  void addFeatureLayer(
      GeoPackage geopkg, FeatureLayer layer, MapLayerInfo mapLayer, WMSMapContent map)
      throws IOException {

    FeatureEntry e = new FeatureEntry();
    initEntry(e, layer, mapLayer, map);

    Filter filter = layer.getQuery().getFilter();
    GeometryDescriptor gd = mapLayer.getFeature().getFeatureType().getGeometryDescriptor();
    if (gd != null) {
      Envelope bnds = bounds(map);
      BBOX bboxFilter =
          filterFactory.bbox(
              gd.getLocalName(),
              bnds.getMinX(),
              bnds.getMinY(),
              bnds.getMaxX(),
              bnds.getMaxY(),
              map.getRequest().getSRS());
      filter = filterFactory.and(filter, bboxFilter);
    }

    LOGGER.fine("Creating feature entry" + e.getTableName());
    geopkg.add(e, layer.getSimpleFeatureSource(), filter);
  }
Example #2
0
  /**
   * Encodes the url of a GetMap request from a map context + map layer.
   *
   * <p>If the <tt>Layer</tt> argument is <code>null</code>, the request is made including all
   * layers in the <tt>mapContexT</tt>.
   *
   * <p>If the <tt>bbox</tt> argument is <code>null</code>. {@link
   * WMSMapContent#getAreaOfInterest()} is used for the bbox parameter.
   *
   * @param mapContent The map context.
   * @param layer The Map layer, may be <code>null</code>.
   * @param layerIndex The index of the layer in the request.
   * @param bbox The bounding box of the request, may be <code>null</code>.
   * @param kvp Additional or overiding kvp parameters, may be <code>null</code>
   * @param tile Flag controlling whether the request should be made against tile cache
   * @param geoserver
   * @return The full url for a getMap request.
   * @deprecated use {@link WMSRequests#getGetMapUrl(WMSMapContent, Layer, Envelope, String[])}
   */
  public static String getMapUrl(
      WMSMapContent mapContent,
      Layer layer,
      int layerIndex,
      Envelope bbox,
      String[] kvp,
      boolean tile,
      GeoServer geoserver) {

    if (tile) {
      org.geoserver.wms.GetMapRequest request = mapContent.getRequest();
      return WMSRequests.getTiledGetMapUrl(geoserver, request, layer, layerIndex, bbox, kvp);
    }

    return WMSRequests.getGetMapUrl(mapContent.getRequest(), layer, layerIndex, bbox, kvp);
  }
 String findBestFormat(WMSMapContent map) {
   // if request is a single coverage layer return jpeg, otherwise use just png
   List<MapLayerInfo> layers = map.getRequest().getLayers();
   if (layers.size() == 1 && layers.get(0).getType() == MapLayerInfo.TYPE_RASTER) {
     return JPEG_MIME_TYPE;
   }
   return PNG_MIME_TYPE;
 }
Example #4
0
  /**
   * Creates the {@link RenderedImage} corresponding to the tile at index {@code tileIdx} and uses a
   * {@link RenderedImageMapResponse} to encode it into the {@link #getResponseFormat() response
   * format}.
   *
   * @see org.geowebcache.layer.MetaTile#writeTileToStream(int, org.geowebcache.io.Resource)
   * @see RenderedImageMapResponse#write
   */
  @Override
  public boolean writeTileToStream(final int tileIdx, Resource target) throws IOException {

    checkNotNull(metaTileMap, "webMap is not set");
    if (!(metaTileMap instanceof RenderedImageMap)) {
      throw new IllegalArgumentException(
          "Only RenderedImageMaps are supported so far: " + metaTileMap.getClass().getName());
    }
    final RenderedImageMapResponse mapEncoder;
    {
      final GWC mediator = GWC.get();
      final Response responseEncoder = mediator.getResponseEncoder(responseFormat, metaTileMap);
      mapEncoder = (RenderedImageMapResponse) responseEncoder;
    }

    RenderedImage tile = metaTileMap.getImage();
    WMSMapContent tileContext = metaTileMap.getMapContext();

    if (this.tiles.length > 1 || (this.tiles.length == 1 && metaHasGutter())) {
      final Rectangle tileDim = this.tiles[tileIdx];
      tile = createTile(tileDim.x, tileDim.y, tileDim.width, tileDim.height);
      disposeLater(tile);
      {
        final WMSMapContent metaTileContext = metaTileMap.getMapContext();
        // do not create tileContext with metaTileContext.getLayers() as the layer list.
        // It is not needed at this stage and the constructor would force a
        // MapLayer.getBounds() that might fail
        tileContext = new WMSMapContent();
        tileContext.setRequest(metaTileContext.getRequest());
        tileContext.setBgColor(metaTileContext.getBgColor());
        tileContext.setMapWidth(tileDim.width);
        tileContext.setMapHeight(tileDim.height);
        tileContext.setPalette(metaTileContext.getPalette());
        tileContext.setTransparent(tileContext.isTransparent());
        long[][] tileIndexes = getTilesGridPositions();
        BoundingBox tileBounds = gridSubset.boundsFromIndex(tileIndexes[tileIdx]);
        ReferencedEnvelope tilebbox =
            new ReferencedEnvelope(metaTileContext.getCoordinateReferenceSystem());
        tilebbox.init(
            tileBounds.getMinX(), tileBounds.getMaxX(), tileBounds.getMinY(), tileBounds.getMaxY());
        tileContext.getViewport().setBounds(tilebbox);
      }
    }

    OutputStream outStream = target.getOutputStream();
    try {
      // call formatImageOuputStream instead of write to avoid disposition of rendered images
      // when processing a tile from a metatile and instead defer it to this class' dispose()
      // method
      mapEncoder.formatImageOutputStream(tile, outStream, tileContext);
      return true;
    } finally {
      outStream.close();
    }
  }
Example #5
0
  /**
   * Returns true if the request is GWC compatible
   *
   * @param mapContent
   * @return
   */
  public static boolean isRequestGWCCompatible(WMSMapContent mapContent, Layer layer, WMS wms) {
    List<Layer> layers = mapContent.layers();
    for (int i = 0; i < layers.size(); i++) {
      if (layers.get(i) == layer) {
        return isRequestGWCCompatible(mapContent.getRequest(), i, wms);
      }
    }
    LOGGER.warning("Could not find map layer " + layer.getTitle() + " in the map context");

    return false;
  }
    public KMLGeometryTranslator(
        ContentHandler handler, int numDecimals, boolean useDummyZ, WMSMapContent context) {
      // super(handler, "kml", "http://earth.google.com/kml/2.0" );
      super(handler, null, null, numDecimals, useDummyZ, 3);
      coordWriter = new KMLCoordinateWriter(numDecimals, useDummyZ);

      String extrudeValue = (String) context.getRequest().getFormatOptions().get("extrude");
      if (extrudeValue != null) {
        extrude = Boolean.valueOf(extrudeValue).booleanValue();
      }

      String requestedAltitudeMode =
          (String) context.getRequest().getFormatOptions().get("altitudeMode");
      if (requestedAltitudeMode != null) {
        for (String mode : validAltitudeModes) {
          if (mode.equalsIgnoreCase(requestedAltitudeMode.trim())) {
            altitudeMode = mode;
          }
        }
      }
    }
 Integer srid(WMSMapContent map) {
   Integer srid = null;
   try {
     srid = CRS.lookupEpsgCode(map.getCoordinateReferenceSystem(), false);
     if (srid == null) {
       srid = Integer.parseInt(map.getRequest().getSRS().split(":")[1]);
     }
   } catch (Exception ex) {
     LOGGER.log(Level.WARNING, "Error determining srid", ex);
   }
   return srid;
 }
  int[] findMinMaxZoom(GridSubset gridSubset, WMSMapContent map) {
    GridSet gridSet = gridSubset.getGridSet();
    Map formatOpts = map.getRequest().getFormatOptions();

    Integer minZoom = null;
    if (formatOpts.containsKey("min_zoom")) {
      minZoom = Integer.parseInt(formatOpts.get("min_zoom").toString());
    }
    if (minZoom == null) {
      minZoom = findClosestZoom(gridSet, map);
    }

    Integer maxZoom = null;
    if (formatOpts.containsKey("max_zoom")) {
      maxZoom = Integer.parseInt(formatOpts.get("max_zoom").toString());
    } else if (formatOpts.containsKey("num_zooms")) {
      maxZoom = minZoom + Integer.parseInt(formatOpts.get("num_zooms").toString());
    }

    if (maxZoom == null) {
      // walk down until we hit too many tiles
      maxZoom = findMaxZoomAuto(gridSubset, minZoom, map);
    }

    if (maxZoom < minZoom) {
      throw new ServiceException(
          format("maxZoom (%d) can not be less than minZoom (%d)", maxZoom, minZoom));
    }

    // end index
    if (maxZoom > gridSet.getNumLevels()) {
      LOGGER.warning(
          format(
              "Max zoom (%d) can't be greater than number of zoom levels (%d)",
              maxZoom, gridSet.getNumLevels()));
      maxZoom = gridSet.getNumLevels();
    }

    return new int[] {minZoom, maxZoom};
  }
Example #9
0
  /**
   * Loads the feature collection based on the current styling and the scale denominator. If no
   * feature is going to be returned a null feature collection will be returned instead
   *
   * @param featureSource
   * @param layer
   * @param mapContent
   * @param wms
   * @param scaleDenominator
   * @return
   * @throws Exception
   */
  public static SimpleFeatureCollection loadFeatureCollection(
      SimpleFeatureSource featureSource,
      Layer layer,
      WMSMapContent mapContent,
      WMS wms,
      double scaleDenominator)
      throws Exception {
    SimpleFeatureType schema = featureSource.getSchema();

    Envelope envelope = mapContent.getRenderingArea();
    ReferencedEnvelope aoi =
        new ReferencedEnvelope(envelope, mapContent.getCoordinateReferenceSystem());
    CoordinateReferenceSystem sourceCrs = schema.getCoordinateReferenceSystem();

    boolean reprojectBBox =
        (sourceCrs != null)
            && !CRS.equalsIgnoreMetadata(aoi.getCoordinateReferenceSystem(), sourceCrs);
    if (reprojectBBox) {
      aoi = aoi.transform(sourceCrs, true);
    }

    Filter filter = createBBoxFilter(schema, aoi);

    // now build the query using only the attributes and the bounding
    // box needed
    Query q = new Query(schema.getTypeName());
    q.setFilter(filter);

    // now, if a definition query has been established for this layer,
    // be sure to respect it by combining it with the bounding box one.
    Query definitionQuery = layer.getQuery();

    if (definitionQuery != Query.ALL) {
      if (q == Query.ALL) {
        q = (Query) definitionQuery;
      } else {
        q = (Query) DataUtilities.mixQueries(definitionQuery, q, "KMLEncoder");
      }
    }

    // handle startIndex requested by client query
    q.setStartIndex(definitionQuery.getStartIndex());

    // check the regionating strategy
    RegionatingStrategy regionatingStrategy = null;
    String stratname = (String) mapContent.getRequest().getFormatOptions().get("regionateBy");
    if (("auto").equals(stratname)) {
      Catalog catalog = wms.getGeoServer().getCatalog();
      Name name = layer.getFeatureSource().getName();
      stratname =
          catalog
              .getFeatureTypeByName(name)
              .getMetadata()
              .get("kml.regionateStrategy", String.class);
      if (stratname == null || "".equals(stratname)) {
        stratname = "best_guess";
        LOGGER.log(
            Level.FINE,
            "No default regionating strategy has been configured in "
                + name
                + "; using automatic best-guess strategy.");
      }
    }

    if (stratname != null) {
      regionatingStrategy = findStrategyByName(stratname);

      // if a strategy was specified but we did not find it, let the user
      // know
      if (regionatingStrategy == null)
        throw new ServiceException("Unknown regionating strategy " + stratname);
    }

    // try to load less features by leveraging regionating strategy and the
    // SLD
    Filter regionatingFilter = Filter.INCLUDE;

    if (regionatingStrategy != null)
      regionatingFilter = regionatingStrategy.getFilter(mapContent, layer);

    Filter ruleFilter =
        summarizeRuleFilters(
            getLayerRules(featureSource.getSchema(), layer.getStyle()), scaleDenominator);
    Filter finalFilter = joinFilters(q.getFilter(), ruleFilter, regionatingFilter);
    if (finalFilter == Filter.EXCLUDE) {
      // if we don't have any feature to return
      return null;
    }
    q.setFilter(finalFilter);

    // make sure we output in 4326 since that's what KML mandates
    CoordinateReferenceSystem wgs84;
    try {
      wgs84 = CRS.decode("EPSG:4326");
    } catch (Exception e) {
      throw new RuntimeException(
          "Cannot decode EPSG:4326, the CRS subsystem must be badly broken...");
    }
    if (sourceCrs != null && !CRS.equalsIgnoreMetadata(wgs84, sourceCrs)) {
      return new ReprojectFeatureResults(featureSource.getFeatures(q), wgs84);
    }

    return featureSource.getFeatures(q);
  }
Example #10
0
 /**
  * Encodes the url for a GetLegendGraphic request from a map context + map layer.
  *
  * @param mapContent The map context.
  * @param layer The map layer.
  * @param kvp Additional or overidding kvp parameters, may be <code>null</code>
  *
  * @return A map containing all the key value pairs for a GetLegendGraphic request.
  * @deprecated use {@link WMSRequests#getGetLegendGraphicUrl(WMSMapContent, Layer, String[])
  */
 public static String getLegendGraphicUrl(WMSMapContent mapContent, Layer layer, String[] kvp) {
   return WMSRequests.getGetLegendGraphicUrl(mapContent.getRequest(), layer, kvp);
 }
  GridSubset findBestGridSubset(WMSMapContent map) {
    GetMapRequest req = map.getRequest();
    Map formatOpts = req.getFormatOptions();

    GridSetBroker gridSetBroker = gwc.getGridSetBroker();
    GridSet gridSet = null;

    // first check format options to see if explicitly specified
    if (formatOpts.containsKey("gridset")) {
      gridSet = gridSetBroker.get(formatOpts.get("gridset").toString());
    }

    // next check srs
    if (gridSet == null) {
      gridSet = gridSetBroker.get(req.getSRS().toUpperCase());
    }

    if (gridSet != null) {
      return GridSubsetFactory.createGridSubSet(gridSet);
    }

    CoordinateReferenceSystem crs = map.getCoordinateReferenceSystem();

    // look up epsg code
    Integer epsgCode = null;
    try {
      epsgCode = CRS.lookupEpsgCode(crs, false);
    } catch (Exception e) {
      throw new ServiceException("Unable to determine epsg code for " + crs, e);
    }
    if (epsgCode == null) {
      throw new ServiceException("Unable to determine epsg code for " + crs);
    }

    SRS srs = SRS.getSRS(epsgCode);

    // figure out the appropriate grid sub set
    Set<GridSubset> gridSubsets = new LinkedHashSet<GridSubset>();
    for (MapLayerInfo l : req.getLayers()) {
      TileLayer tl = gwc.getTileLayerByName(l.getName());
      if (tl == null) {
        throw new ServiceException("No tile layer for " + l.getName());
      }

      List<GridSubset> theseGridSubsets = tl.getGridSubsetsForSRS(srs);
      if (gridSubsets.isEmpty()) {
        gridSubsets.addAll(theseGridSubsets);
      } else {
        gridSubsets.retainAll(theseGridSubsets);
      }

      if (gridSubsets.isEmpty()) {
        throw new ServiceException(
            "No suitable " + epsgCode + " grid subset for " + req.getLayers());
      }
    }

    if (gridSubsets.size() > 1) {
      if (LOGGER.isLoggable(Level.WARNING)) {
        StringBuilder msg = new StringBuilder("Found multiple grid subsets: ");
        for (GridSubset gs : gridSubsets) {
          msg.append(gs.getName()).append(", ");
        }
        msg.setLength(msg.length() - 2);
        msg.append(". Choosing first.");
        LOGGER.warning(msg.toString());
      }
    }

    return gridSubsets.iterator().next();
  }
 ReferencedEnvelope bounds(WMSMapContent map) {
   return new ReferencedEnvelope(map.getRequest().getBbox(), map.getCoordinateReferenceSystem());
 }
  void addTileLayers(GeoPackage geopkg, List<MapLayerInfo> mapLayers, WMSMapContent map)
      throws IOException {

    if (mapLayers.isEmpty()) {
      return;
    }

    // figure out a name for the file entry
    String tileEntryName = null;
    Map formatOpts = map.getRequest().getFormatOptions();
    if (formatOpts.containsKey("tileset_name")) {
      tileEntryName = (String) formatOpts.get("tileset_name");
    }
    if (tileEntryName == null) {
      tileEntryName = map.getTitle();
    }
    if (tileEntryName == null && mapLayers.size() == 1) {
      Iterator<MapLayerInfo> it = mapLayers.iterator();
      tileEntryName = it.next().getLayerInfo().getName();
    }

    GridSubset gridSubset = findBestGridSubset(map);
    int[] minmax = findMinMaxZoom(gridSubset, map);

    BoundingBox bbox = bbox(map);

    TileEntry e = new TileEntry();
    e.setTableName(tileEntryName);

    if (mapLayers.size() == 1) {
      ResourceInfo r = mapLayers.get(0).getResource();
      e.setIdentifier(r.getTitle());
      e.setDescription(r.getAbstract());
    }
    e.setBounds(
        new ReferencedEnvelope(
            findTileBounds(gridSubset, bbox, minmax[0]), map.getCoordinateReferenceSystem()));
    e.setSrid(srid(map));

    GridSet gridSet = gridSubset.getGridSet();
    for (int z = minmax[0]; z < minmax[1]; z++) {
      Grid g = gridSet.getGrid(z);

      TileMatrix m = new TileMatrix();
      m.setZoomLevel(z);
      m.setMatrixWidth((int) g.getNumTilesWide());
      m.setMatrixHeight((int) g.getNumTilesHigh());
      m.setTileWidth(gridSubset.getTileWidth());
      m.setTileHeight(gridSubset.getTileHeight());

      // TODO: not sure about this
      m.setXPixelSize(g.getResolution());
      m.setYPixelSize(g.getResolution());
      // m.setXPixelSize(gridSet.getPixelSize());
      // m.setYPixelSize(gridSet.getPixelSize());

      e.getTileMatricies().add(m);
    }

    // figure out the actual bounds of the tiles to be renderered
    LOGGER.fine("Creating tile entry" + e.getTableName());
    geopkg.create(e);

    // create a prototype getmap request
    GetMapRequest req = new GetMapRequest();
    OwsUtils.copy(map.getRequest(), req, GetMapRequest.class);
    req.setLayers(mapLayers);

    String imageFormat =
        formatOpts.containsKey("format") ? parseFormatFromOpts(formatOpts) : findBestFormat(map);

    req.setFormat(imageFormat);
    req.setWidth(gridSubset.getTileWidth());
    req.setHeight(gridSubset.getTileHeight());

    // count tiles as we generate them
    int ntiles = 0;

    // flag determining if tile row indexes we store in database should be inverted
    boolean flipy = Boolean.valueOf((String) formatOpts.get("flipy"));
    for (int z = minmax[0]; z < minmax[1]; z++) {
      long[] intersect = gridSubset.getCoverageIntersection(z, bbox);
      for (long x = intersect[0]; x <= intersect[2]; x++) {
        for (long y = intersect[1]; y <= intersect[3]; y++) {
          BoundingBox box = gridSubset.boundsFromIndex(new long[] {x, y, z});
          req.setBbox(new Envelope(box.getMinX(), box.getMaxX(), box.getMinY(), box.getMaxY()));

          Tile t = new Tile();
          t.setZoom(z);
          t.setColumn((int) x);
          t.setRow((int) (flipy ? gridSubset.getNumTilesHigh(z) - (y + 1) : y));

          WebMap result = webMapService.getMap(req);
          t.setData(toBytes(result));

          geopkg.add(e, t);

          // images we encode are actually kept around, we need to clean them up
          if (ntiles++ == TILE_CLEANUP_INTERVAL) {
            cleanUpImages();
            ntiles = 0;
          }
        }
      }
    }
  }
  @Override
  public WebMap produceMap(WMSMapContent map) throws ServiceException, IOException {
    GeoPackage geopkg = new GeoPackage();
    geopkg.init();

    GetMapRequest req = map.getRequest();

    List<Layer> layers = map.layers();
    List<MapLayerInfo> mapLayers = req.getLayers();

    Preconditions.checkState(
        layers.size() == mapLayers.size(),
        "Number of map layers not same as number of rendered layers");

    // list of layers to render directly and include as tiles
    List<MapLayerInfo> tileLayers = new ArrayList();

    // check mode, one of:
    // vector - render vector layers as feature entries and all else as tiles (default)
    // hybrid - render vector layers as feature entries, raster layers as raster entries, all
    //          others as tile entries
    // tiled - all layers as a single tile set
    Map formatOpts = req.getFormatOptions();
    Mode mode =
        formatOpts.containsKey("mode")
            ? Mode.valueOf(((String) formatOpts.get("mode")).toUpperCase())
            : Mode.VECTOR;

    if (mode == Mode.TILED) {
      // tiled mode means render all as map tile layer
      tileLayers.addAll(mapLayers);
    } else {

      // hybrid mode, dump as raw vector or raster unless the request specifically asks for a
      // layer to be rendered as tiles
      for (int i = 0; i < layers.size(); i++) {
        Layer layer = layers.get(i);
        MapLayerInfo mapLayer = mapLayers.get(i);

        if (layer instanceof FeatureLayer) {
          addFeatureLayer(geopkg, (FeatureLayer) layer, mapLayer, map);
        } else if (layer instanceof GridCoverageLayer) {
          if (mode == Mode.HYBRID) {
            addCoverageLayer(geopkg, (GridCoverageLayer) layer, mapLayer, map);
          } else {
            tileLayers.add(mapLayer);
          }
        } else {
          tileLayers.add(mapLayer);
        }
      }
    }

    addTileLayers(geopkg, tileLayers, map);

    geopkg.close();

    final File dbFile = geopkg.getFile();
    final BufferedInputStream bin = new BufferedInputStream(new FileInputStream(dbFile));

    RawMap result =
        new RawMap(map, bin, MIME_TYPE) {
          @Override
          public void writeTo(OutputStream out) throws IOException {
            String dbFilename = getAttachmentFileName();
            if (dbFilename != null) {
              dbFilename = dbFilename.substring(0, dbFilename.length() - 4) + ".gpkg";
            } else {
              // this shouldn't really ever happen, but fallback anyways
              dbFilename = "geoserver.gpkg";
            }

            IOUtils.copy(bin, out);
            out.flush();

            //               JD: disabling zip compression for now
            //                ZipOutputStream zout = new ZipOutputStream(out);
            //                zout.putNextEntry(new ZipEntry(dbFilename));
            //
            //                super.writeTo(zout);
            //                zout.closeEntry();
            //                zout.close();

            bin.close();
            try {
              dbFile.delete();
            } catch (Exception e) {
              LOGGER.log(Level.WARNING, "Error deleting file: " + dbFile.getAbsolutePath(), e);
            }
          }
        };

    result.setContentDispositionHeader(map, ".gpkg", true);
    return result;
  }