コード例 #1
0
  /**
   * Causes resources used by the World Window to be freed. The World Window cannot be used once
   * this method is called. An OpenGL context for the window must be current.
   */
  public void shutdown() {
    WorldWind.getDataFileStore().removePropertyChangeListener(this);

    if (this.inputHandler != null) {
      this.inputHandler.dispose();
      this.inputHandler = new NoOpInputHandler();
    }

    // Clear the texture cache
    if (this.getGpuResourceCache() != null) this.getGpuResourceCache().clear();

    // Dispose all the layers //  TODO: Need per-window dispose for layers
    if (this.getModel() != null && this.getModel().getLayers() != null) {
      for (Layer layer : this.getModel().getLayers()) {
        try {
          layer.dispose();
        } catch (Exception e) {
          Logging.logger()
              .log(
                  java.util.logging.Level.SEVERE,
                  Logging.getMessage("WorldWindowGLCanvas.ExceptionWhileShuttingDownWorldWindow"),
                  e);
        }
      }
    }

    SceneController sc = this.getSceneController();
    if (sc != null) sc.dispose();
  }
    public ByteBuffer run(Retriever retriever) {
      if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL)) return null;

      HTTPRetriever htr = (HTTPRetriever) retriever;
      if (htr.getResponseCode() == HttpURLConnection.HTTP_NO_CONTENT) {
        // Mark tile as missing to avoid excessive attempts
        MercatorTiledImageLayer.this.levels.markResourceAbsent(tile);
        return null;
      }

      if (htr.getResponseCode() != HttpURLConnection.HTTP_OK) return null;

      URLRetriever r = (URLRetriever) retriever;
      ByteBuffer buffer = r.getBuffer();

      String suffix = WWIO.makeSuffixForMimeType(htr.getContentType());
      if (suffix == null) {
        return null; // TODO: log error
      }

      String path = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
      path += suffix;

      final File outFile = WorldWind.getDataFileStore().newFile(path);
      if (outFile == null) return null;

      try {
        WWIO.saveBuffer(buffer, outFile);
        return buffer;
      } catch (IOException e) {
        e.printStackTrace(); // TODO: log error
        return null;
      }
    }
コード例 #3
0
  public WorldWindowImpl() {
    this.sceneController =
        (SceneController) WorldWind.createConfigurationComponent(AVKey.SCENE_CONTROLLER_CLASS_NAME);

    // Set up to initiate a repaint whenever a file is retrieved and added to the local file store.
    WorldWind.getDataFileStore().addPropertyChangeListener(this);
  }
コード例 #4
0
  /**
   * Resolves a reference to a remote element identified by address and identifier, where {@code
   * linkBase} identifies a remote document, and {@code linkRef} is the id of the desired element.
   * This method retrieves resources asynchronously using the {@link
   * gov.nasa.worldwind.cache.FileStore}.
   *
   * <p>The return value is null if the file is not yet available in the FileStore. If {@code
   * linkBase} refers to a COLLADA file and {@code linkRef} is non-null, the return value is the
   * element identified by {@code linkRef}. If {@code linkBase} refers to a COLLADA file and {@code
   * linkRef} is null, the return value is a parsed {@link ColladaRoot} for the COLLADA file
   * identified by {@code linkBase}. Otherwise the return value is a {@link URL} to the file in the
   * file cache.
   *
   * @param linkBase the address of the document containing the requested element.
   * @param linkRef the element's identifier.
   * @return URL to the requested file, parsed ColladaRoot, or COLLADA element. Returns null if the
   *     document is not yet available in the FileStore.
   * @throws IllegalArgumentException if the {@code linkBase} is null.
   */
  public Object resolveRemoteReference(String linkBase, String linkRef) {
    if (linkBase == null) {
      String message = Logging.getMessage("nullValue.DocumentSourceIsNull");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    try {
      // See if it's in the cache. If not, requestFile will start another thread to retrieve it and
      // return null.
      URL url = WorldWind.getDataFileStore().requestFile(linkBase);
      if (url == null) return null;

      // It's in the cache. If it's a COLLADA file try to parse it so we can search for the
      // specified reference.
      // If it's not COLLADA, just return the url for the cached file.
      String contentType = WorldWind.getDataFileStore().getContentType(linkBase);
      if (contentType == null) {
        String suffix = WWIO.getSuffix(linkBase.split(";")[0]); // strip of trailing garbage
        if (!WWUtil.isEmpty(suffix)) contentType = WWIO.makeMimeTypeForSuffix(suffix);
      }

      if (!this.canParseContentType(contentType)) return url;

      // If the file is a COLLADA document, attempt to open it. We can't open it as a File with
      // createAndParse
      // because the ColladaRoot that will be created needs to have the remote address in order to
      // resolve any
      // relative references within it.
      ColladaRoot refRoot = this.parseCachedColladaFile(url, linkBase);

      // Add the parsed file to the session cache so it doesn't have to be parsed again.
      WorldWind.getSessionCache().put(linkBase, refRoot);

      // Now check the newly opened COLLADA file for the referenced item, if a reference was
      // specified.
      if (linkRef != null) return refRoot.getItemByID(linkRef);
      else return refRoot;
    } catch (Exception e) {
      String message =
          Logging.getMessage("generic.UnableToResolveReference", linkBase + "/" + linkRef);
      Logging.logger().warning(message);
      return null;
    }
  }
コード例 #5
0
  /*
   * Load cache locations
   */
  private void loadData() {
    // load combo with WW caches
    // List<File> caches =  WorldWind.getDataFileCache().getCacheLocations();
    List<? extends File> caches = WorldWind.getDataFileStore().getLocations();

    for (File file : caches) {
      combo.add(file.toString());
    }

    // load table w/ 1st location files
    // loadTable(caches.get(0));
  }
コード例 #6
0
  @Override
  protected boolean handleElevations(
      Globe globe, TextureTile tile, Sector sector, BufferWrapper[] elevations) {
    int width = tile.getLevel().getTileWidth();
    int height = tile.getLevel().getTileHeight();

    double[] minmax = getMinMax(elevations[4], elevationModel.getMissingDataSignal());
    byte[][] bytes =
        elevationsToTexture(width, height, globe, sector, elevations, minmax[0], minmax[1]);

    File file = WorldWind.getDataFileStore().newFile(tile.getPath());
    return saveTexture(file, bytes, width, height, minmax[0], minmax[1]);
  }
  private BufferedImage requestImage(MercatorTextureTile tile, String mimeType)
      throws URISyntaxException {
    String pathBase = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
    String suffix = WWIO.makeSuffixForMimeType(mimeType);
    String path = pathBase + suffix;
    URL url = WorldWind.getDataFileStore().findFile(path, false);

    if (url == null) // image is not local
    return null;

    if (WWIO.isFileOutOfDate(url, tile.getLevel().getExpiryTime())) {
      // The file has expired. Delete it.
      WorldWind.getDataFileStore().removeFile(url);
      String message = Logging.getMessage("generic.DataFileExpired", url);
      Logging.logger().fine(message);
    } else {
      try {
        File imageFile = new File(url.toURI());
        BufferedImage image = ImageIO.read(imageFile);
        if (image == null) {
          String message = Logging.getMessage("generic.ImageReadFailed", imageFile);
          throw new RuntimeException(message);
        }

        this.levels.unmarkResourceAbsent(tile);
        return image;
      } catch (IOException e) {
        // Assume that something's wrong with the file and delete it.
        gov.nasa.worldwind.WorldWind.getDataFileStore().removeFile(url);
        this.levels.markResourceAbsent(tile);
        String message = Logging.getMessage("generic.DeletedCorruptDataFile", url);
        Logging.logger().info(message);
      }
    }

    return null;
  }
コード例 #8
0
/**
 * Represents a texture derived from a lazily loaded image source such as an image file or a {@link
 * java.awt.image.BufferedImage}.
 *
 * <p>The interface contains a method, {@link #isTextureInitializationFailed()} to determine whether
 * the instance failed to convert an image source to a texture. If such a failure occurs, the method
 * returns true and no further attempts are made to create the texture.
 *
 * <p>This class performs lazy retrieval and loading of an image source, attempting to retrieve and
 * load the image source only when the {@link #bind(DrawContext)} or {@link
 * #applyInternalTransform(DrawContext)} methods are called. If the image source is a {@link
 * BufferedImage} the associated {@link Texture} object is created and available immediately when
 * <code>bind</code> or <code>applyInternalTransform</code> are called. If the image source is a
 * local file or remote stream (URL), retrieval and loading is performed on a separate thread from
 * the EDT.
 *
 * @author tag
 * @version $Id$
 */
public class LazilyLoadedTexture extends AVListImpl implements WWTexture {
  /** The original image source specified at construction. */
  protected Object imageSource;
  /** The mip-map flag specified at construction. */
  protected boolean useMipMaps;
  /** The current anisotropy flag. */
  protected boolean useAnisotropy = true;

  /** The texture width, if the width is known. Otherwise it's -1. */
  protected Integer width;
  /** The texture height, if the height is known. Otherwise it's -1. */
  protected Integer height;
  /** The texture's texture coordinates, as determined by JOGL when the texture is created. */
  protected TextureCoords texCoords;
  /**
   * The texture data created as the image source is read. It's removed - set to null - once the
   * textures is fully created. This intermediate texture data is necessary because the image source
   * is read in a non-EDT thread. This field is <code>volatile</code> in order to synchronize atomic
   * access among threads. This field is not used if the image source is <code>BufferedImage</code>.
   */
  protected volatile TextureData textureData; // if non-null, then must be converted to a Texture
  /** Indicates that texture initialization failed. This texture should not be used if true. */
  protected boolean textureInitializationFailed = false;
  /** Indicates whether the image read from the image source has mip-map data. */
  protected boolean hasMipmapData = false;
  /**
   * Identifies the {@link gov.nasa.worldwind.cache.FileStore} of the supporting file cache for this
   * model.
   */
  protected FileStore fileStore = WorldWind.getDataFileStore();
  /**
   * Provides a semaphore to synchronize access to the texture file if duplicate request tasks are
   * active.
   */
  protected final Object fileLock = new Object();

  /**
   * The object to notify when an image is eventually loaded in memory. The current layer at the
   * time the image source is requested is assigned to this field.
   */
  protected PropertyChangeListener listener;

  /**
   * Constructs a texture object for a specified image source. Requests that mip-maps be used.
   *
   * @param imageSource the source of the image, either a file path {@link String} or a {@link
   *     java.awt.image.BufferedImage}.
   * @throws IllegalArgumentException if the <code>imageSource</code> is null.
   */
  public LazilyLoadedTexture(Object imageSource) {
    this(imageSource, true);
  }

  /**
   * Constructs a texture object for a specified image source.
   *
   * @param imageSource the source of the image, either a file path {@link String} or a {@link
   *     java.awt.image.BufferedImage}.
   * @param useMipMaps Indicates whether to generate and use mip-maps for the image.
   * @throws IllegalArgumentException if the <code>imageSource</code> is null.
   */
  public LazilyLoadedTexture(Object imageSource, boolean useMipMaps) {
    initialize(imageSource, useMipMaps, null);
  }

  /**
   * Initializes this object's fields during construction.
   *
   * @param imageSource the image source.
   * @param useMipMaps the mip-map flag.
   * @param listener the change listener.
   * @throws IllegalArgumentException if the image source is null.
   */
  protected void initialize(
      Object imageSource, boolean useMipMaps, PropertyChangeListener listener) {
    if (imageSource == null) {
      String message = Logging.getMessage("nullValue.ImageSource");
      Logging.logger().severe(message);
      throw new IllegalArgumentException(message);
    }

    this.imageSource = imageSource;
    this.useMipMaps = useMipMaps;

    if (listener != null) this.addPropertyChangeListener(listener);
  }

  public Object getImageSource() {
    return this.imageSource;
  }

  /**
   * Indicates whether the image source is a <code>BufferedImage</code>
   *
   * @return true if the image source is a <code>BufferedImage</code>, otherwise false.
   */
  protected boolean isBufferedImageSource() {
    return this.getImageSource() instanceof BufferedImage;
  }

  /**
   * Indicates the texture's width, which is the same as the image source's width. The width is
   * known only after the image source has been retrieved from disk or network and read as <code>
   * TextureData</code>. It's value is -1 until then.
   *
   * @return the texture's width if the texture has been retrieved, otherwise -1.
   */
  public int getWidth() {
    return this.width != null ? this.width : -1;
  }

  /**
   * Indicates the texture's height, which is the same as the image source's height. The height is
   * known only after the image source has been retrieved from disk or network and read as <code>
   * TextureData</code>. It's value is -1 until then.
   *
   * @return the texture's height if the texture has been retrieved, otherwise -1.
   */
  public int getHeight() {
    return this.height != null ? this.height : -1;
  }

  /**
   * {@inheritDoc}
   *
   * <p>This method behaves identically to {@link #getWidth()}. The <code>DrawContext</code>
   * argument is not used.
   *
   * @param dc this parameter is not used by this class.
   * @return the texture's width if the texture has been retrieved, otherwise -1.
   */
  public int getWidth(DrawContext dc) {
    return this.getWidth();
  }

  /**
   * {@inheritDoc}
   *
   * <p>This method behaves identically to {@link #getHeight()}. The <code>DrawContext</code>
   * argument is not used.
   *
   * @param dc this parameter is not used by this class.
   * @return the texture's height if the texture has been retrieved, otherwise -1.
   */
  public int getHeight(DrawContext dc) {
    return this.getHeight();
  }

  /**
   * Indicates whether the texture should use mip-maps. If they are not available in the source
   * image they are created.
   *
   * @return true if mip-maps are used, false if not.
   */
  public boolean isUseMipMaps() {
    return this.useMipMaps;
  }

  public TextureCoords getTexCoords() {
    return this.texCoords;
  }

  public boolean isTextureCurrent(DrawContext dc) {
    return this.getTexture(dc) != null;
  }

  /**
   * Indicates whether texture anisotropy is applied to the texture when rendered.
   *
   * @return useAnisotropy true if anisotropy is to be applied, otherwise false.
   */
  public boolean isUseAnisotropy() {
    return this.useAnisotropy;
  }

  /**
   * Specifies whether texture anisotropy is applied to the texture when rendered.
   *
   * @param useAnisotropy true if anisotropy is to be applied, otherwise false.
   */
  public void setUseAnisotropy(boolean useAnisotropy) {
    this.useAnisotropy = useAnisotropy;
  }

  /**
   * Indicates whether an attempt was made to retrieve and read the texture but it failed. If this
   * flag is true, this texture should not be used.
   *
   * @return true if texture retrieval or creation failed, otherwise true, even if the image source
   *     has not yet been retrieved.
   */
  public boolean isTextureInitializationFailed() {
    return this.textureInitializationFailed;
  }

  /**
   * Returns the {@link Texture} associated with this instance.
   *
   * @param dc the current draw context.
   * @return this instance's texture, or null if the texture does not currently exist.
   */
  protected Texture getTexture(DrawContext dc) {
    if (this.getImageSource() == null) return null;

    Texture texture = dc.getTextureCache().getTexture(this.getImageSource());

    if (this.width == null && texture != null) {
      this.width = texture.getWidth();
      this.height = texture.getHeight();
      this.texCoords = texture.getImageTexCoords();
    }

    return texture;
  }

  /**
   * Returns this texture's texture data if it has been retrieved but a <code>Texture</code> has not
   * yet been created for it.
   *
   * <p>If this object's texture data field is non-null, a new texture is created from the texture
   * data when the tile is next bound or otherwise initialized. This object's texture data field is
   * then set to null.
   *
   * @return the texture data, which may be null indicating that the image source has not been read
   *     or that a texture has been created.
   */
  protected TextureData getTextureData() {
    return this.textureData;
  }

  /**
   * Specifies texture data for the tile. If texture data is non-null, a new texture is created from
   * the texture data when the tile is next bound.
   *
   * <p>When a texture is created from the texture data, the texture data field is set to null to
   * indicate that the data has been converted to a texture and its resources may be released.
   *
   * @param textureData the texture data, which may be null.
   */
  protected void setTextureData(TextureData textureData) {
    this.textureData = textureData;
    if (textureData != null && textureData.getMipmapData() != null) this.hasMipmapData = true;
  }

  /**
   * Binds this instance's {@link Texture} to the <code>GLContext</code> if the texture has been
   * created, otherwise initiates image source retrieval and texture creation in a separate thread.
   *
   * @param dc the current draw context.
   * @return true if the texture was bound, otherwise false.
   */
  public boolean bind(DrawContext dc) {
    if (this.isTextureInitializationFailed()) return false;

    if (dc == null) {
      String message = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    Texture texture = this.getTexture(dc);
    if (texture == null) texture = this.requestTexture(dc);

    if (texture != null) {
      texture.bind();
      return true;
    } else {
      return false;
    }
  }

  public void applyInternalTransform(DrawContext dc) {
    if (dc == null) {
      String message = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    Texture texture = this.getTexture(dc);
    if (texture == null) texture = this.requestTexture(dc);

    if (texture == null) return;

    if (texture.getMustFlipVertically()) {
      GL gl = GLContext.getCurrent().getGL();
      gl.glMatrixMode(GL.GL_TEXTURE);
      gl.glLoadIdentity();
      gl.glScaled(1, -1, 1);
      gl.glTranslated(0, -1, 0);
    }
  }

  /**
   * If this instance's image source is a <code>BufferedImage</code>, creates and returns the
   * texture, otherwise creates a task in a separate thread to retrieve it from its local or remote
   * location.
   *
   * @param dc the current draw context.
   * @return the new texture, or null if the texture is not yet available.
   */
  protected Texture requestTexture(DrawContext dc) {
    if (this.isBufferedImageSource()) return this.makeBufferedImageTexture(dc);

    if (this.getTextureData() != null && this.getTexture(dc) == null)
      return this.makeTextureFromTextureData(dc);

    if (WorldWind.getTaskService().isFull()) return null;

    Runnable task = this.createRequestTask();
    if (WorldWind.getTaskService().contains(task)) return null;

    // Use either the current layer or the layer list as the listener to notify when the request
    // completes. The
    // latter is used when the image source is requested during ordered rendering and the current
    // layer is null.
    this.listener = dc.getCurrentLayer() != null ? dc.getCurrentLayer() : dc.getLayers();

    WorldWind.getTaskService().addTask(task);

    return null;
  }

  /**
   * Returns an object that implements the Runnable interface, and who's <code>run</code> method
   * retrieves and loads this texture's image source.
   *
   * @return a new request task that retrieves and loads this texture's image source.
   */
  protected Runnable createRequestTask() {
    return new RequestTask(this);
  }

  /**
   * Creates this instance's {@link Texture} if the image source is a <code>BufferedImage<code>.
   *
   * @param dc the current draw context.
   *
   * @return the newly created texture, or null if the texture was not created.
   *
   * @throws IllegalStateException if the image source is null or not a <code>BufferedImage</code>.
   */
  protected Texture makeBufferedImageTexture(DrawContext dc) {
    if (this.getImageSource() == null || !(this.getImageSource() instanceof BufferedImage)) {
      String message = Logging.getMessage("generic.NotABufferedImage");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    try {
      TextureData td =
          TextureIO.newTextureData((BufferedImage) this.getImageSource(), this.isUseMipMaps());
      if (td == null) return null;

      this.setTextureData(td);

      return this.makeTextureFromTextureData(dc);
    } catch (Exception e) {
      String msg = Logging.getMessage("generic.IOExceptionDuringTextureInitialization");
      Logging.logger().log(java.util.logging.Level.SEVERE, msg, e);
      this.textureInitializationFailed = true;
      return null;
    }
  }

  /**
   * Creates a {@link Texture} from this instance's {@link TextureData} if the <code>TextureData
   * </code> exists.
   *
   * @param dc the current draw context.
   * @return the newly created texture, or null if this instance has no current <code>TextureData
   *     </code> or if texture creation failed.
   */
  protected Texture makeTextureFromTextureData(DrawContext dc) {
    if (dc == null) {
      String message = Logging.getMessage("nullValue.DrawContextIsNull");
      Logging.logger().severe(message);
      throw new IllegalStateException(message);
    }

    if (this.getTextureData()
        == null) // texture not in cache yet texture data is null, can't initialize
    {
      String msg = Logging.getMessage("nullValue.TextureDataIsNull");
      Logging.logger().severe(msg);
      throw new IllegalStateException(msg);
    }

    try {
      Texture texture = TextureIO.newTexture(this.getTextureData());
      if (texture == null) {
        this.textureInitializationFailed = true;
        return null;
      }

      this.width = texture.getWidth();
      this.height = texture.getHeight();
      this.texCoords = texture.getImageTexCoords();

      this.setTextureParameters(dc, texture);

      // Cache the texture and release the texture data.
      dc.getTextureCache().put(this.getImageSource(), texture);
      this.setTextureData(null);

      return texture;
    } catch (Exception e) {
      String name =
          this.isBufferedImageSource() ? "BufferedImage" : this.getImageSource().toString();
      String msg = Logging.getMessage("generic.ExceptionAttemptingToCreateTexture", name);
      Logging.logger().log(java.util.logging.Level.SEVERE, msg, e);
      return null;
    }
  }

  /**
   * Sets a specified texture's OpenGL <code>Texture</code> parameters.
   *
   * @param dc the current draw context.
   * @param texture the texture whose parameters to set.
   */
  protected void setTextureParameters(DrawContext dc, Texture texture) {
    // Enable the appropriate mip-mapping texture filters if the caller has specified that
    // mip-mapping should be
    // enabled, and the texture itself supports mip-mapping.
    boolean useMipMapFilter =
        this.useMipMaps
            && (this.getTextureData().getMipmapData() != null
                || texture.isUsingAutoMipmapGeneration());

    GL gl = dc.getGL();
    gl.glTexParameteri(
        GL.GL_TEXTURE_2D,
        GL.GL_TEXTURE_MIN_FILTER,
        useMipMapFilter ? GL.GL_LINEAR_MIPMAP_LINEAR : GL.GL_LINEAR);
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);

    if (this.isUseAnisotropy() && useMipMapFilter) {
      double maxAnisotropy = dc.getGLRuntimeCapabilities().getMaxTextureAnisotropy();
      if (dc.getGLRuntimeCapabilities().isUseAnisotropicTextureFilter() && maxAnisotropy >= 2.0) {
        gl.glTexParameterf(
            GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, (float) maxAnisotropy);
      }
    }
  }

  protected void notifyTextureLoaded() {
    if (this.listener != null) {
      this.listener.propertyChange(new PropertyChangeEvent(this, AVKey.TEXTURE, null, this));
      this.listener = null; // forget the listener to avoid dangling references
    }
  }

  /**
   * Attempts to find this texture's image file locally, and if that fails attempts to find it
   * remotely.
   */
  protected static class RequestTask implements Runnable {
    /** The BasicWWTexture associated with this request. */
    protected final LazilyLoadedTexture wwTexture;

    /**
     * Construct a request task for a specified BasicWWTexture.
     *
     * @param wwTexture the texture object for which to construct the request task.
     */
    protected RequestTask(LazilyLoadedTexture wwTexture) {
      if (wwTexture == null) {
        String message = Logging.getMessage("nullValue.TextureIsNull");
        Logging.logger().severe(message);
        throw new IllegalArgumentException(message);
      }

      this.wwTexture = wwTexture;
    }

    public void run() {
      if (Thread.currentThread().isInterrupted())
        return; // the task was cancelled because it's a duplicate or for some other reason

      URL fileUrl =
          this.wwTexture.fileStore.requestFile(this.wwTexture.getImageSource().toString());

      if (fileUrl != null) {
        if (this.wwTexture.loadTextureData(fileUrl)) {
          this.wwTexture.notifyTextureLoaded();
        }
      }
    }

    public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;

      final RequestTask that = (RequestTask) o;

      return !(this.wwTexture != null
          ? !this.wwTexture.equals(that.wwTexture)
          : that.wwTexture != null);
    }

    public int hashCode() {
      return (this.wwTexture != null ? this.wwTexture.hashCode() : 0);
    }

    public String toString() {
      return this.wwTexture.getImageSource().toString();
    }
  }

  /**
   * Loads the image from disk into memory. If successful, texture data is created and available via
   * {@link #getTextureData()}.
   *
   * @param fileUrl the URL of the image file.
   * @return true if the image was successfully loaded, otherwise false.
   */
  protected boolean loadTextureData(URL fileUrl) {
    TextureData td;

    synchronized (this.fileLock) {
      td = readImage(fileUrl);

      if (td != null) this.setTextureData(td);
    }

    return this.getTextureData() != null;
  }

  /**
   * Reads and returns a {@link TextureData} for an image from a specified file URL.
   *
   * @param fileUrl the URL of the image file to read.
   * @return a <code>TextureData</code> instance for the image.
   */
  protected TextureData readImage(URL fileUrl) {
    try {
      return TextureIO.newTextureData(fileUrl, this.isUseMipMaps(), null);
    } catch (Exception e) {
      String msg =
          Logging.getMessage(
              "layers.TextureLayer.ExceptionAttemptingToReadTextureFile", this.getImageSource());
      Logging.logger().log(java.util.logging.Level.SEVERE, msg, e);
      this.textureInitializationFailed = true;
      return null;
    }
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    LazilyLoadedTexture that = (LazilyLoadedTexture) o;

    //noinspection RedundantIfStatement
    if (imageSource != null ? !imageSource.equals(that.imageSource) : that.imageSource != null)
      return false;

    return true;
  }

  @Override
  public int hashCode() {
    return imageSource != null ? imageSource.hashCode() : 0;
  }
}
コード例 #9
0
  @Override
  protected boolean loadTexture(TextureTile tile, URL textureURL) {
    if (!(tile instanceof MinMaxTextureTile)) {
      Logging.logger().severe("Tile is not instance of " + MinMaxTextureTile.class);
      getLevels().markResourceAbsent(tile);
      return false;
    }

    synchronized (fileLock) {
      InputStream is = null;
      try {
        is = textureURL.openStream();
        DataInputStream dis = new DataInputStream(is);

        int width = dis.readInt();
        int height = dis.readInt();
        int bands = dis.readInt();
        double minElevation = dis.readDouble();
        double maxElevation = dis.readDouble();
        byte[][] bytes = new byte[bands][];
        for (int i = 0; i < bands; i++) {
          bytes[i] = new byte[width * height];
          is.read(bytes[i]);
        }

        DataBuffer db = new DataBufferByte(bytes, width * height);
        SampleModel sm = new BandedSampleModel(DataBuffer.TYPE_BYTE, width, height, bands);
        Raster raster = Raster.createRaster(sm, db, null);
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE);
        image.setData(raster);

        TextureData textureData = TextureIO.newTextureData(image, isUseMipMaps());
        if (textureData == null) {
          throw new Exception("Could not create texture data for " + textureURL);
        }

        ((MinMaxTextureTile) tile).setMinElevation(minElevation);
        ((MinMaxTextureTile) tile).setMaxElevation(maxElevation);
        tile.setTextureData(textureData);

        // if (tile.getLevelNumber() != 0 || !this.isRetainLevelZeroTiles())
        addTileToCache(tile);

        getLevels().unmarkResourceAbsent(tile);
        firePropertyChange(AVKey.LAYER, null, this);
        return true;
      } catch (Exception e) {
        // Assume that something's wrong with the file and delete it.
        gov.nasa.worldwind.WorldWind.getDataFileStore().removeFile(textureURL);
        getLevels().markResourceAbsent(tile);
        String message = Logging.getMessage("generic.DeletedCorruptDataFile", textureURL);
        Logging.logger().info(message + ":" + e.getLocalizedMessage());
        return false;
      } finally {
        if (is != null) {
          try {
            is.close();
          } catch (IOException e) {
          }
        }
      }
    }
  }