/** * Creates a parser for band arithmetic expressions. * The parser created will use a namespace comprising all tie-point grids, bands and flags of this product. * * @return a parser for band arithmetic expressions for this product, never null */ public Parser createBandArithmeticParser() { final Namespace namespace = createBandArithmeticDefaultNamespace(); return new ParserImpl(namespace, false); }
private ParserImpl createFallbackParser() { final Namespace fallbackNS = new DummyNamespace(); final DefaultNamespace defaultNS = new DefaultNamespace(fallbackNS); return new ParserImpl(defaultNS, false); }
private Term createTerm(String expression) { Namespace namespace = createNamespace(); final Term term; try { Parser parser = new ParserImpl(namespace, false); term = parser.parse(expression); } catch (ParseException e) { String msg = MessageFormat.format("Could not parse expression: ''{0}''. {1}", expression, e.getMessage()); throw new OperatorException(msg, e); } return term; }
private boolean isValidExpression() { final Product[] products = getCompatibleProducts(); if (products.length == 0 || getExpression().isEmpty()) { return false; } final int defaultIndex = Arrays.asList(products).indexOf(targetProduct); final Namespace namespace = BandArithmetic.createDefaultNamespace(products, defaultIndex == -1 ? 0 : defaultIndex); final Parser parser = new ParserImpl(namespace, false); try { parser.parse(getExpression()); } catch (ParseException e) { return false; } return true; }
@Before public void setUp() throws Exception { env = new EvalEnv() { }; parser = new ParserImpl(); }
defaultIndex == -1 ? 0 : defaultIndex); setParser(new ParserImpl(namespace, false));
/** * Parses the given expression. * * @param expression the expression * @param products the array of input products * @param defaultProductIndex the index of the product for which also symbols without the * product prefix <code>$<i>ref-no</i></code> are registered in the namespace * @return the compiled expression * @throws ParseException if a parse error occurs */ public static Term parseExpression(String expression, Product[] products, int defaultProductIndex) throws ParseException { Assert.notNull(expression, null); final Namespace namespace = createDefaultNamespace(products, defaultProductIndex); final Parser parser = new ParserImpl(namespace, false); return parser.parse(expression); }
private void initParser() { final String sourceName = getSelectedSourceName(); final Variable sourceVariable = SymbolFactory.createVariable(sourceName, 0.0); final DefaultNamespace namespace = new DefaultNamespace(); namespace.registerSymbol(sourceVariable); setParser(new ParserImpl(namespace, true)); }
defaultProductIndex); namespace.registerSymbol(SymbolFactory.createConstant(paramName.getValueAsText(), 0)); final Term term = new ParserImpl(namespace, false).parse(expression); if (!term.isB()) { JOptionPane.showMessageDialog(dialog.getJDialog(),
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; }
for (MosaicOp.Variable variable : variables) { try { new ParserImpl(namespace, false).parse(variable.getExpression()); } catch (ParseException e) { final String msg = String.format("Expression '%s' is invalid for product '%s'.\n%s", for (MosaicOp.Condition condition : conditions) { try { new ParserImpl(namespace, false).parse(condition.getExpression()); } catch (ParseException e) { final String msg = String.format("Expression '%s' is invalid for product '%s'.\n%s",
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"); } } } }
public void testThatPerformanceIsSufficient() throws ParseException, IOException { final Band flags = new Band("flags", ProductData.TYPE_INT8, 1, 1); final SingleFlagSymbol s1 = new SingleFlagSymbol("flags.WATER", flags, 0x01); final SingleFlagSymbol s2 = new SingleFlagSymbol("flags.LAND", flags, 0x02); final SingleFlagSymbol s3 = new SingleFlagSymbol("flags.CLOUD", flags, 0x04); final int[] dataElems = new int[]{-1}; s1.setData(dataElems); s2.setData(dataElems); s3.setData(dataElems); final DefaultNamespace namespace = new DefaultNamespace(); namespace.registerSymbol(s1); namespace.registerSymbol(s2); namespace.registerSymbol(s3); final String code = "(flags.WATER OR flags.LAND) AND NOT flags.CLOUD"; final Term term = new ParserImpl(namespace, true).parse(code); final RasterDataEvalEnv evalEnv = new RasterDataEvalEnv(0, 0, 1, 1); long t1 = System.currentTimeMillis(); for (int i = 0; i < MAX_NUM_TEST_LOOPS; i++) { } long t2 = System.currentTimeMillis(); for (int i = 0; i < MAX_NUM_TEST_LOOPS; i++) { term.evalI(evalEnv); } long t3 = System.currentTimeMillis(); long dt = (t3 - t2) - (t2 - t1); long numOps = Math.round(MAX_NUM_TEST_LOOPS * (1000.0 / dt)); // System.out.println("numOps = " + numOps); assertTrue(String.format("Low evaluation performance detected (%d ops/s for term \"%s\"): Term implementation change?", numOps, code), numOps > MIN_NUM_OPS_PER_SECOND); }
Parser verificationParser = new ParserImpl(namespace, true); for (BandDescriptor bandDescriptor : targetBandDescriptors) { createBand(bandDescriptor, verificationParser);
@Test public void testPow() throws ParseException { NamespaceImpl namespace = new NamespaceImpl(new DefaultNamespace()); namespace.registerSymbol(new AbstractSymbol.I("ix") { @Override public int evalI(EvalEnv env) throws EvalException { return ix; } }); namespace.registerSymbol(new AbstractSymbol.D("dx") { @Override public double evalD(EvalEnv env) throws EvalException { return dx; } }); ParserImpl parser = new ParserImpl(namespace); ix = 1; dx = 1.0; assertEquals(10.0, parser.parse("pow(10, ix)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, ix)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, dx)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, dx)").evalD(null), 1E-10); ix = 2; dx = 2.0; assertEquals(100.0, parser.parse("pow(10.0, ix)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, ix)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, dx)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, dx)").evalD(null), 1E-10); }