/** * Returns true if the specified file store path can be opened as an XML document, and calling {@link * #accept(org.w3c.dom.Document)} returns true. * * @param fileStore the file store containing the named file path. * @param fileName the named file path in question. * * @return true if the file name should be accepted; false otherwise. * * @throws ArgumentException if either the file store or the file name are null. */ public bool accept(FileStore fileStore, String fileName) { if (fileStore == null) { String msg = Logging.getMessage("nullValue.FileStoreIsNull"); Logging.logger().severe(msg); throw new ArgumentException(msg); } if (fileName == null) { String message = Logging.getMessage("nullValue.FilePathIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // Attempt to locate the named path in the FileStore, optionally checking the class path. If a file with that // name cannot be located, then return false. java.net.URL url = fileStore.findFile(fileName, true); if (url == null) { return(false); } // Attempt to convert the URL to a local file path. If that succeeds, then continue treating the URL as if // it were a File. java.io.File file = WWIO.convertURLToFile(url); if (file != null) { return(this.accept(file)); } return(this.accept(url)); }
protected void loadOffsetFile() { InputStream inputStream = WWIO.openFileOrResourceStream(this.offsetsFilePath, typeof(EGM96)); if (inputStream == null) { String msg = Logging.getMessage("generic.CannotOpenFile", this.offsetsFilePath); Logging.logger().severe(msg); throw new WWRuntimeException(msg); } try { AVList bufferParams = new AVListImpl(); bufferParams.setValue(AVKey.DATA_TYPE, AVKey.INT16); bufferParams.setValue(AVKey.BYTE_ORDER, AVKey.BIG_ENDIAN); this.deltas = BufferWrapper.wrap(WWIO.readStreamToBuffer(is, true), bufferParams); } catch (IOException e) { String msg = Logging.getMessage("generic.ExceptionAttemptingToReadFile", this.offsetsFilePath); Logging.logger().log(java.util.logging.Level.SEVERE, msg, e); throw e; } finally { WWIO.closeStream(is, this.offsetsFilePath); } }
protected bool doCanRead(Object source, AVList parameters) { String path = WWIO.getSourcePath(source); if (path == null) { return(false); } GeotiffReader reader = null; try { reader = new GeotiffReader(path); bool isGeoTiff = reader.isGeotiff(0); if (!isGeoTiff) { isGeoTiff = WorldFile.hasWorldFiles(source); } return(isGeoTiff); } catch (Exception e) { // Intentionally ignoring exceptions. return(false); } finally { if (reader != null) { reader.close(); } } }
public ComposeImageTile(Sector sector, String mimeType, Level level, int width, int height) { super(sector, level, -1, -1); // row and column aren't used and need to signal that this.width = width; this.height = height; this.file = File.createTempFile(WWIO.DELETE_ON_EXIT_PREFIX, WWIO.makeSuffixForMimeType(mimeType)); }
public VPFFeatureClassSchema[] getFeatureClasses(FileFilter featureTableFilter) { if (featureTableFilter == null) { String message = Logging.getMessage("nullValue.FilterIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } // List the file names in the coverage directory matching the specified feature table file filter. String[] names = WWIO.listChildFilenames(new File(this.getFilePath()), featureTableFilter); if (names == null) { return(null); } int numFeatures = names.length; VPFFeatureClassSchema[] desc = new VPFFeatureClassSchema[numFeatures]; for (int i = 0; i < numFeatures; i++) { String featureTableName = names[i]; String className = WWIO.replaceSuffix(featureTableName, ""); String type = null; // If the Feature Class Attriute Table is available, then use it to determine the feature type for the // specified class. if (this.featureClassAttributeTable != null) { VPFRecord record = this.featureClassAttributeTable.getRecord("fclass", className); if (record != null) { type = (String)record.getValue("type"); } } // Otherwise, determine the feature type is based on the feature table extension. if (type == null) { type = VPFUtils.getFeatureTypeName(featureTableName); } desc[i] = new VPFFeatureClassSchema(className, VPFFeatureType.fromTypeName(type), featureTableName); } return(desc); }
protected bool doCanRead(Object source, AVList parameters) { if (WWUtil.isEmpty(source)) { return(false); } if (null == parameters) { File file = WWIO.getFileForLocalAddress(source); if (null == file) { return(false); } return(GDALUtils.canOpen(file)); } bool canOpen = false; GDALDataRaster raster = null; try { raster = new GDALDataRaster(source, true); // read data raster quietly parameters.setValues(raster.getMetadata()); canOpen = true; } catch (Throwable t) { // we purposely ignore any exception here, this should be a very quiet mode canOpen = false; } finally { if (null != raster) { raster.dispose(); raster = null; } } return(canOpen); }
public static String getFeatureTypeName(String tableName) { if (tableName == null) { String message = Logging.getMessage("nullValue.StringIsNull"); Logging.logger().severe(message); throw new ArgumentException(message); } String suffix = WWIO.getSuffix(tableName); if (suffix == null) { return(null); } suffix = "." + suffix; if (suffix.equalsIgnoreCase(VPFConstants.POINT_FEATURE_TABLE)) { return(VPFConstants.POINT_FEATURE_TYPE); } else if (suffix.equalsIgnoreCase(VPFConstants.LINE_FEATURE_TABLE)) { return(VPFConstants.LINE_FEATURE_TYPE); } else if (suffix.equalsIgnoreCase(VPFConstants.AREA_FEATURE_TABLE)) { return(VPFConstants.AREA_FEATURE_TYPE); } else if (suffix.equalsIgnoreCase(VPFConstants.TEXT_FEATURE_TABLE)) { return(VPFConstants.TEXT_FEATURE_TYPE); } else if (suffix.equalsIgnoreCase(VPFConstants.COMPLEX_FEATURE_TABLE)) { return(VPFConstants.COMPLEX_FEATURE_TYPE); } return(null); }
//**************************************************************// //******************** Configuration *************************// //**************************************************************// /** * Parses WMSBasicElevationModel configuration parameters from a specified WMS Capabilities source. This writes * output as key-value pairs to parameters. Supported key and parameter names are: <table> * <th><td>Parameter</td><td>Value</td><td>Type</td></th> <tr><td>{@link AVKey#ELEVATION_MAX}</td><td>WMS layer's * maximum extreme elevation</td><td>Double</td></tr> <tr><td>{@link AVKey#ELEVATION_MIN}</td><td>WMS layer's * minimum extreme elevation</td><td>Double</td></tr> <tr><td>{@link AVKey#DATA_TYPE}</td><td>Translate WMS layer's * image format to a matching data type</td><td>String</td></tr> </table> This also parses common WMS layer * parameters by invoking {@link DataConfigurationUtils#getWMSLayerConfigParams(gov.nasa.worldwind.ogc.wms.WMSCapabilities, * String[], SharpEarth.avlist.AVList)}. * * @param caps the WMS Capabilities source to parse for WMSBasicElevationModel configuration * parameters. * @param formatOrderPreference an ordered array of preferred image formats, or null to use the default format. * @param parameters the output key-value pairs which recieve the WMSBasicElevationModel configuration * parameters. * * @return a reference to parameters. * * @throws ArgumentException if either the document or parameters are null, or if parameters does not contain the * required key-value pairs. * @throws SharpEarth.exception.WWRuntimeException * if the Capabilities document does not contain any of the required information. */ public static AVList getWMSElevationModelConfigParams(WMSCapabilities caps, String[] formatOrderPreference, AVList parameters) { if (caps == null) { String message = Logging.getMessage("nullValue.WMSCapabilities"); Logging.logger().severe(message); throw new ArgumentException(message); } if (parameters == null) { String message = Logging.getMessage("nullValue.ElevationModelConfigParams"); Logging.logger().severe(message); throw new ArgumentException(message); } // Get common WMS layer parameters. DataConfigurationUtils.getWMSLayerConfigParams(caps, formatOrderPreference, parameters); // Attempt to extract the WMS layer names from the specified parameters. String layerNames = parameters.getStringValue(AVKey.LAYER_NAMES); if (layerNames == null || layerNames.Length == 0) { String message = Logging.getMessage("nullValue.WMSLayerNames"); Logging.logger().severe(message); throw new ArgumentException(message); } String[] names = layerNames.Split(','); if (names == null || names.Length == 0) { String message = Logging.getMessage("nullValue.WMSLayerNames"); Logging.logger().severe(message); throw new ArgumentException(message); } // Get the layer's extreme elevations. Double[] extremes = caps.getLayerExtremeElevations(names); Double d = (Double)parameters.getValue(AVKey.ELEVATION_MIN); if (d == null && extremes != null && extremes[0] != null) { parameters.setValue(AVKey.ELEVATION_MIN, extremes[0]); } d = (Double)parameters.getValue(AVKey.ELEVATION_MAX); if (d == null && extremes != null && extremes[1] != null) { parameters.setValue(AVKey.ELEVATION_MAX, extremes[1]); } // Compute the internal pixel type from the image format. if (parameters.getValue(AVKey.DATA_TYPE) == null && parameters.getValue(AVKey.IMAGE_FORMAT) != null) { String s = WWIO.makeDataTypeForMimeType(parameters.getValue(AVKey.IMAGE_FORMAT).ToString()); if (s != null) { parameters.setValue(AVKey.DATA_TYPE, s); } } // Use the default data type. if (parameters.getValue(AVKey.DATA_TYPE) == null) { parameters.setValue(AVKey.DATA_TYPE, AVKey.INT16); } // Use the default byte order. if (parameters.getValue(AVKey.BYTE_ORDER) == null) { parameters.setValue(AVKey.BYTE_ORDER, AVKey.LITTLE_ENDIAN); } return(parameters); }
/** * Determine if a host is reachable by attempting to resolve the host name, and then attempting to open a * connection. * * @param hostName Name of the host to connect to. * * @return {@code true} if a the host is reachable, {@code false} if the host name cannot be resolved, or if opening * a connection to the host fails. */ protected static bool isHostReachable(String hostName) { try { // Assume host is unreachable if we can't get its dns entry without getting an exception //noinspection ResultOfMethodCallIgnored InetAddress.getByName(hostName); } catch (UnknownHostException e) { String message = Logging.getMessage("NetworkStatus.UnreachableTestHost", hostName); Logging.logger().fine(message); return(false); } catch (Exception e) { String message = Logging.getMessage("NetworkStatus.ExceptionTestingHost", hostName); Logging.logger().info(message); return(false); } // Was able to get internet address, but host still might not be reachable because the address might have been // cached earlier when it was available. So need to try something else. URLConnection connection = null; try { URL url = new URL("http://" + hostName); Proxy proxy = WWIO.configureProxy(); if (proxy != null) { connection = url.openConnection(proxy); } else { connection = url.openConnection(); } connection.setConnectTimeout(2000); connection.setReadTimeout(2000); String ct = connection.getContentType(); if (ct != null) { return(true); } } catch (IOException e) { String message = Logging.getMessage("NetworkStatus.ExceptionTestingHost", hostName); Logging.logger().info(message); } finally { if (connection != null && connection is HttpURLConnection) { ((HttpURLConnection)connection).disconnect(); } } return(false); }
protected Texture initializeTexture(DrawContext dc, Object imageSource) { if (dc == null) { String message = Logging.getMessage("nullValue.DrawContextIsNull"); Logging.logger().severe(message); throw new IllegalStateException(message); } if (this.textureInitializationFailed) { return(null); } Texture t; bool haveMipMapData; GL gl = dc.getGL(); if (imageSource is String) { String path = (String)imageSource; Object streamOrException = WWIO.getFileOrResourceAsStream(path, this.GetType()); if (streamOrException == null || streamOrException is Exception) { Logging.logger().log(java.util.logging.Level.SEVERE, "generic.ExceptionAttemptingToReadImageFile", streamOrException != null ? streamOrException : path); this.textureInitializationFailed = true; return(null); } try { TextureData td = OGLUtil.newTextureData(gl.getGLProfile(), (InputStream)streamOrException, this.useMipMaps); t = TextureIO.newTexture(td); haveMipMapData = td.getMipmapData() != null; } catch (Exception e) { String msg = Logging.getMessage("layers.TextureLayer.ExceptionAttemptingToReadTextureFile", imageSource); Logging.logger().log(java.util.logging.Level.SEVERE, msg, e); this.textureInitializationFailed = true; return(null); } } else if (imageSource is BufferedImage) { try { TextureData td = AWTTextureIO.newTextureData(gl.getGLProfile(), (BufferedImage)imageSource, this.useMipMaps); t = TextureIO.newTexture(td); haveMipMapData = td.getMipmapData() != null; } catch (Exception e) { String msg = Logging.getMessage("generic.IOExceptionDuringTextureInitialization"); Logging.logger().log(java.util.logging.Level.SEVERE, msg, e); this.textureInitializationFailed = true; return(null); } } else if (imageSource is URL) { try { InputStream stream = ((URL)imageSource).openStream(); if (stream == null) { Logging.logger().log(java.util.logging.Level.SEVERE, "generic.ExceptionAttemptingToReadImageFile", imageSource); this.textureInitializationFailed = true; return(null); } TextureData td = OGLUtil.newTextureData(gl.getGLProfile(), stream, this.useMipMaps); t = TextureIO.newTexture(td); haveMipMapData = td.getMipmapData() != null; } catch (Exception e) { String msg = Logging.getMessage("layers.TextureLayer.ExceptionAttemptingToReadTextureFile", imageSource); Logging.logger().log(java.util.logging.Level.SEVERE, msg, e); this.textureInitializationFailed = true; return(null); } } else { Logging.logger().log(java.util.logging.Level.SEVERE, "generic.UnrecognizedImageSourceType", imageSource.GetType().Name); this.textureInitializationFailed = true; return(null); } if (t == null) // In case JOGL TextureIO returned null { Logging.logger().log(java.util.logging.Level.SEVERE, "generic.TextureUnreadable", imageSource is String ? imageSource : imageSource.GetType().Name); this.textureInitializationFailed = true; return(null); } // Textures with the same path are assumed to be identical textures, so key the texture id off the // image source. dc.getTextureCache().put(imageSource, t); t.bind(gl); // 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. bool useMipMapFilter = this.useMipMaps && (haveMipMapData || t.isUsingAutoMipmapGeneration()); 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); } } this.width = t.getWidth(); this.height = t.getHeight(); this.texCoords = t.getImageTexCoords(); return(t); }