/** * Creates a namespace to be used by parsers for band arithmetic expressions. * The namespace created comprises all tie-point grids, bands and flags of this product. * * @return a namespace, never null */ public WritableNamespace createBandArithmeticDefaultNamespace() { return BandArithmetic.createDefaultNamespace(new Product[]{this}, 0); }
/** * Utility method which returns all raster data symbols references in a given term. * * @param term the term to be analysed * @return the array of raster data symbols, never <code>null</code> but may be empty */ public static RasterDataSymbol[] getRefRasterDataSymbols(Term term) { return getRefRasterDataSymbols(new Term[]{term}); }
public static RasterDataNode[] getRefRasters(String expression, Product... products) throws ParseException { return getRefRasters(expression, products, 0); }
public static RasterDataNode[] getRefRasters(String expression, Product[] products, int defaultProductNamePrefix) throws ParseException { RasterDataSymbol[] symbols = getRefRasterDataSymbols( new Term[]{parseExpression(expression, products, defaultProductNamePrefix)}); RasterDataNode[] rasters = new RasterDataNode[symbols.length]; for (int i = 0; i < symbols.length; i++) { rasters[i] = symbols[i].getRaster(); } return rasters; }
private static String createUnambiguousExpression(String vme, Product[] products, int productIndex) throws ParseException { RasterDataNode[] rasters = getRefRasters(vme, products, productIndex); for (RasterDataNode raster : rasters) { String name = raster.getName(); namePos = vme.indexOf(name, namePos); if (namePos == 0) { String prefix = getProductNodeNamePrefix(raster.getProduct()); vme = prefix + vme; namePos += name.length() + prefix.length(); char c1 = vme.charAt(i1); char c2 = i2 < vme.length() ? vme.charAt(i2) : '\0'; if (c1 != '.' && !isNameChar(c1) && !isNameChar(c2)) { String prefix = getProductNodeNamePrefix(raster.getProduct()); vme = vme.substring(0, namePos) + prefix + vme.substring(namePos); namePos += name.length() + prefix.length();
private static void appendSpectrumBandNames(List<String> bandNames, boolean normalize, StringBuilder arguments) { String firstName = BandArithmetic.createExternalName(bandNames.get(0)); for (int i = 0; i < bandNames.size(); i++) { if (i > 0) { arguments.append(","); } String name = BandArithmetic.createExternalName(bandNames.get(i)); if (normalize) { arguments.append(name).append("/").append(firstName); } else { arguments.append(name); } } }
private void collectReferencedRastersInExpression(String expression, ArrayList<String> referencedNodeNames) { if (expression == null || expression.trim().isEmpty()) { return; } try { final Term term = sourceProduct.parseExpression(expression); final RasterDataSymbol[] refRasterDataSymbols = BandArithmetic.getRefRasterDataSymbols(term); final RasterDataNode[] refRasters = BandArithmetic.getRefRasters(refRasterDataSymbols); if (refRasters.length > 0) { for (RasterDataNode refRaster : refRasters) { final String refNodeName = refRaster.getName(); if (!referencedNodeNames.contains(refNodeName)) { referencedNodeNames.add(refNodeName); collectReferencedRastersInExpression(refNodeName, referencedNodeNames); } } } } catch (ParseException e) { getLogger().log(Level.WARNING, e.getMessage(), e); } }
private boolean isTargetBandReferencedInExpression() { final Product[] products = getCompatibleProducts(); final int defaultIndex = Arrays.asList(products).indexOf(visatApp.getSelectedProduct()); final Namespace namespace = BandArithmetic.createDefaultNamespace(products, defaultIndex == -1 ? 0 : defaultIndex); final Parser parser = new ParserImpl(namespace, false); try { final Term term = parser.parse(getExpression()); final RasterDataSymbol[] refRasterDataSymbols = BandArithmetic.getRefRasterDataSymbols(term); String bName = getBandName(); if (targetProduct.containsRasterDataNode(bName)) { for (final RasterDataSymbol refRasterDataSymbol : refRasterDataSymbols) { final String refRasterName = refRasterDataSymbol.getRaster().getName(); if (bName.equalsIgnoreCase(refRasterName)) { return true; } } } } catch (ParseException e) { return false; } return false; }
Product[] products = getCompatibleProducts(rasterDataNode); int defaultProductIndex = Arrays.asList(products).indexOf(product); final WritableNamespace namespace = BandArithmetic.createDefaultNamespace(products, defaultProductIndex); namespace.registerSymbol(SymbolFactory.createConstant(paramName.getValueAsText(), 0)); Product[] products = getCompatibleProducts(virtualBand); int defaultProductIndex = Arrays.asList(products).indexOf(product); BandArithmetic.getValidMaskExpression(expression, products, defaultProductIndex, null); } catch (ParseException e) { JOptionPane.showMessageDialog(dialog.getJDialog(),
public void testCreateDefaultNamespaceWithMultipleProducts() { final Namespace namespace = BandArithmetic.createDefaultNamespace(new Product[]{_product1, _product2}, 0); final Symbol symbolP1 = namespace.resolveSymbol("$1.b1"); assertNotNull(symbolP1); assertTrue(symbolP1 instanceof RasterDataSymbol); assertEquals("$1.b1", symbolP1.getName()); final Symbol symbolWithoutPrefix = namespace.resolveSymbol("b1"); assertNotNull(symbolWithoutPrefix); assertTrue(symbolP1 instanceof RasterDataSymbol); assertEquals("b1", symbolWithoutPrefix.getName()); final RasterDataNode[] refRasters = BandArithmetic.getRefRasters(new RasterDataSymbol[]{ (RasterDataSymbol) symbolWithoutPrefix, (RasterDataSymbol) symbolP1 }); assertEquals(1, refRasters.length); final Symbol symbolP2 = namespace.resolveSymbol("$2.b1"); assertNotNull(symbolP2); assertEquals("$2.b1", symbolP2.getName()); final Symbol symbolNotFound = namespace.resolveSymbol("fails"); assertNull(symbolNotFound); }
private static String createValidMaskExpression(Product product, final String expression) throws ParseException { return BandArithmetic.getValidMaskExpression(expression, new Product[]{product}, 0, null); }
Assert.argument(defaultProductIndex >= 0 && defaultProductIndex < products.length, "defaultProductIndex"); final RasterDataNode[] rasters = getRefRasters(expression, products, defaultProductIndex); if (rasters.length == 0) { return validMaskExpression; if (vme != null) { if (raster.getProduct() != contextProduct) { final int productIndex = getProductIndex(products, raster); Assert.state(productIndex >= 0, "productIndex >= 0"); vme = createUnambiguousExpression(vme, products, productIndex);
BandArithmetic.getValidMaskExpression(expression, new Product[]{contextProduct}, 0, null); } catch (ParseException e) { String errorMessage = "The source band could not be created.\nThe expression could not be parsed:\n" + e.getMessage(); /*I18N*/ if (!validExpression.isEmpty()) { try { BandArithmetic.parseExpression(validExpression, new Product[]{contextProduct}, 0); } catch (ParseException e) { String errorMessage = "The valid pixel expression could not be parsed:\n" + e.getMessage(); /*I18N*/
final Scaling scaling, ProgressMonitor pm) throws ParseException, IOException { final Term term = parseExpression(expression, sourceProducts, defaultProductIndex); final Term validMaskTerm; if (validMaskExpression != null && !validMaskExpression.trim().isEmpty()) { validMaskTerm = parseExpression(validMaskExpression, sourceProducts, defaultProductIndex); } else { validMaskTerm = null; return computeBand(term, validMaskTerm, checkInvalids, noDataValueUsed, noDataValue, offsetX, offsetY, width, height,
private String getNodeNamePrefix() { final String namePrefix; if (currentProduct != targetProduct) { namePrefix = BandArithmetic.getProductNodeNamePrefix(currentProduct); } else { namePrefix = ""; } return namePrefix; }
protected String createMaskExpression(double x0, double y0, double dx, double dy) { return String.format("sqrt(sqr((%s - %s)/%s) + sqr((%s - %s)/%s)) < 1.0", BandArithmetic.createExternalName(dataSourceConfig.xBand.getName()), x0, dx, BandArithmetic.createExternalName(dataSourceConfig.yBand.getName()), y0, dy); } };
final RasterDataSymbol[] refRasterDataSymbols = BandArithmetic.getRefRasterDataSymbols(terms); return BandArithmetic.getRefRasters(refRasterDataSymbols);
public void testGetRefRasterDataSymbols() throws ParseException { final Product[] products = new Product[]{_product1, _product2}; final Parser parser = new ParserImpl(BandArithmetic.createDefaultNamespace(products, 0), false); String[] expectedSymbols = new String[]{"b1", "$2.b1"}; final Term term = parser.parse("b1 + $2.b1"); final RasterDataSymbol[] rasterSymbols = BandArithmetic.getRefRasterDataSymbols(term); assertEquals(2, rasterSymbols.length); for (int i = 0; i < expectedSymbols.length; i++) { String expectedSymbol = expectedSymbols[i]; boolean found = false; for (int j = 0; j < rasterSymbols.length; j++) { RasterDataSymbol rasterSymbol = rasterSymbols[j]; if (expectedSymbol.equals(rasterSymbol.getName())) { found = true; break; } } if (!found) { fail("Expected symbol {" + expectedSymbol + "} not found"); } } } }
private Term parseExpression() { final Term term; try { term = BandArithmetic.parseExpression(expression, products, defaultProductIndex); } catch (ParseException e) { throw new RuntimeException(MessageFormat.format( "Could not parse expression: ''{0}''. {1}", expression, e.getMessage()), e); } final ImageManager imageManager = ImageManager.getInstance(); for (final RasterDataSymbol symbol : BandArithmetic.getRefRasterDataSymbols(term)) { if (imageManager.getSourceImage(symbol.getRaster(), getLevel()) == this) { throw new RuntimeException(MessageFormat.format( "Invalid reference ''{0}''.", symbol.getName())); } } return term; }
static void setMagicWandMask(Product product, String expression) { String validMaskExpression; try { validMaskExpression = BandArithmetic.getValidMaskExpression(expression, new Product[]{product}, 0, null); } catch (ParseException e) { validMaskExpression = null; } if (validMaskExpression != null) { expression = "(" + validMaskExpression + ") && (" + expression + ")"; } final Mask magicWandMask = product.getMaskGroup().get(MAGIC_WAND_MASK_NAME); if (magicWandMask != null) { magicWandMask.getImageConfig().setValue("expression", expression); } else { product.addMask(MAGIC_WAND_MASK_NAME, expression, "Magic wand mask", Color.RED, 0.5); } }