ParameterValueGroup readParameters = format.getReadParameters(); List<GeneralParameterDescriptor> descriptors = readParameters.getDescriptor().descriptors(); String pdCode = pv.getDescriptor().getName().getCode(); if ("FILTER".equals(pdCode) || "Filter".equals(pdCode)) { replacedOriginalFilter = true; ParameterValue pvalue = (ParameterValue) pv; Filter originalFilter = (Filter) pvalue.getValue(); if (originalFilter == null || Filter.INCLUDE.equals(originalFilter)) { pvalue.setValue(readFilter); } else { Filter combined = Predicates.and(originalFilter, readFilter); pvalue.setValue(combined); JTS.toGeometry((Envelope) new ReferencedEnvelope(grid.getEnvelope2D())); if (coverageBounds.intersects(rasterFilter)) { final ParameterValueGroup param = cropParams.clone(); param.parameter("source").setValue(grid); param.parameter("ROI").setValue(rasterFilter); grid = (GridCoverage2D) coverageCropFactory.doOperation(param, null);
/** * Computes the difference between the ellipsoid and geoid at a specified lat/lon using Geotools EarthGravitationalModel * * @param lat * @param lon * @return difference in meters * @throws FactoryException * @throws TransformException */ public static double computeEllipsoidToGeoidDifference(double lat, double lon) throws FactoryException, TransformException { // Set up a MathTransform based on the EarthGravitationalModel EarthGravitationalModel.Provider provider = new EarthGravitationalModel.Provider(); DefaultMathTransformFactory factory = new DefaultMathTransformFactory(); MathTransform mt = factory.createParameterizedTransform(provider.getParameters().createValue()); // Compute the offset DirectPosition3D dest = new DirectPosition3D(); mt.transform(new DirectPosition3D(lon, lat, 0), dest); return dest.z; } }
/** Returns the operation name for the specified parameters. */ static String getOperationName(final ParameterValueGroup parameters) { return parameters.getDescriptor().getName().getCode().trim(); }
/** * Constructs a group with the same values than the specified one. This copy constructor may be * used in order to wraps an arbitrary implementation into a Geotools one. * * @since 2.2 */ public DefaultParameterDescriptorGroup(final ParameterDescriptorGroup group) { super(group); maximumOccurs = group.getMaximumOccurs(); final List<GeneralParameterDescriptor> c = group.descriptors(); parameters = c.toArray(new GeneralParameterDescriptor[c.size()]); }
for (final GeneralParameterValue value : values.values()) { final String name = value.getDescriptor().getName().getCode(); if (value instanceof ParameterValueGroup) { descriptor = copy.getDescriptor().descriptor(name); if (descriptor instanceof ParameterDescriptorGroup) { final ParameterValueGroup groups = (ParameterValueGroup) descriptor.createValue(); copy((ParameterValueGroup) value, groups); values.groups(name).add(groups); continue; } else { throw exception; final Object v = source.getValue(); final Unit<?> unit = source.getUnit(); if (unit == null) { target.setValue(v); } else if (v instanceof Number) { target.setValue(((Number) v).doubleValue(), unit);
@Test public void testMathTransformUsesSphericalParameter() throws Exception { Mollweide.MollweideProvider mollweideProvider = new Mollweide.MollweideProvider(); ParameterValueGroup parameters = Mollweide.MollweideProvider.PARAMETERS.createValue(); parameters.parameter(SEMI_MAJOR).setValue(6000); parameters.parameter(SEMI_MINOR).setValue(100); MathTransform mathTransform = mollweideProvider.createMathTransform(parameters); String wkt = mathTransform.toWKT(); Assert.assertTrue(wkt.contains("\"semi_major\", 6000.0")); Assert.assertTrue( "Mollweide is only spherically defined. Axis must be equal", wkt.contains("\"semi_minor\", 6000.0")); } }
this.rasterManager.parentReader.getFormat().getReadParameters(); if (readParams == null) { if (LOGGER.isLoggable(Level.FINER)) readParams.getDescriptor().descriptors(); for (GeneralParameterDescriptor descriptor : parametersDescriptors) { final ReferenceIdentifier name = desc.getName(); final Object value = desc.getDefaultValue(); if (descriptor.getName().equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName())) { if (value == null) continue; final GridGeometry2D gg = (GridGeometry2D) value; if (name.equals(AbstractGridFormat.DECIMATION_POLICY.getName())) { if (value == null) continue; decimationPolicy = (DecimationPolicy) value;
out.write(name); out.write(lineSeparator); Collection<GenericName> alias = group.getAlias(); if (alias != null) { boolean first = true; final Collection<?> elements = (values != null) ? values.values() : group.descriptors(); for (final Object element : elements) { final GeneralParameterValue generalValue; final Identifier identifier = generalDescriptor.getName(); table.write(identifier.getCode()); alias = generalDescriptor.getAlias(); if (alias != null) { for (final GenericName a : alias) { value = descriptor.getMaximumValue(); if (value != null) { table.write(formatValue(value)); value = ((ParameterValue) generalValue).getValue(); format(name + '/' + descriptor.getName().getCode(), descriptor, value);
String name = getName(param, group.getDescriptor().getName().getAuthority()); if (name == null) { name = param.getName().getCode(); if (param.getMinimumOccurs() != 0) { return Parameters.cast(group.parameter(name), param.getValueClass()); search = group.getDescriptor().descriptor(name); if (search instanceof ParameterDescriptor) { for (final GeneralParameterValue candidate : group.values()) {
/** * Verifies the parameter values of the given Universal Transverse Mercator projection. * * @param parameters the parameter value to verify. * @param cm the expected central meridian value. */ private static void verifyTransverseMercatorParmeters(final ParameterValueGroup parameters, final double cm) { assertEquals("Transverse Mercator", parameters.getDescriptor().getName().getCode()); assertEquals("central_meridian", cm, parameters.parameter("central_meridian" ).doubleValue(), STRICT); assertEquals("latitude_of_origin", 0, parameters.parameter("latitude_of_origin").doubleValue(), STRICT); assertEquals("scale_factor", 0.9996, parameters.parameter("scale_factor" ).doubleValue(), STRICT); assertEquals("false_easting", 500000, parameters.parameter("false_easting" ).doubleValue(), STRICT); assertEquals("false_northing", 0, parameters.parameter("false_northing" ).doubleValue(), STRICT); }
throws IOException { final ParameterValueGroup readParametersDescriptor = reader.getFormat().getReadParameters(); CoverageInfo coverage = mapLayerInfo.getCoverage(); MetadataMap metadata = coverage.getMetadata(); readParametersDescriptor.getDescriptor().descriptors()); Set<ParameterDescriptor<List>> dynamicParameters = reader.getDynamicParameters(); parameterDescriptors.addAll(dynamicParameters); GeneralParameterDescriptor pd = param.getDescriptor(); if (pd.getName().getCode().equalsIgnoreCase("FILTER")) { final ParameterValue pv = (ParameterValue) pd.createValue(); pv.setValue(layerFilter); readParameters[i] = pv; GeneralParameterDescriptor pd = param.getDescriptor(); if (pd.getName().getCode().equalsIgnoreCase("SORTING")) { final ParameterValue pv = (ParameterValue) pd.createValue(); if (pd instanceof ParameterDescriptor && String.class.equals(((ParameterDescriptor) pd).getValueClass())) {
int[] getSelectedBandIndexes(GeneralParameterValue[] parameters) { // if the delegate cannot do band selection, don't bother if (delegate.getFormat() == null || !delegate.getFormat() .getReadParameters() .getDescriptor() .descriptors() .contains(AbstractGridFormat.BANDS)) { return null; } // lookup the bands if possible if (parameters != null) { for (int i = 0; i < parameters.length; i++) { final ParameterValue param = (ParameterValue) parameters[i]; if (AbstractGridFormat.BANDS.getName().equals(param.getDescriptor().getName())) { int[] bandIndicesParam = (int[]) param.getValue(); return bandIndicesParam; } } } return null; }
(ParameterDescriptorGroup) CC_GeneralOperationParameter.merge(provided, complete); assertNotSame(complete, provided); assertSame ("name", complete.getName(), merged.getName()); assertSame ("remarks", complete.getRemarks(), merged.getRemarks()); assertEquals ("minimumOccurs", 1, merged.getMinimumOccurs()); assertEquals ("maximumOccurs", 2, merged.getMaximumOccurs()); final Iterator<GeneralParameterDescriptor> itc = complete.descriptors().iterator(); final Iterator<GeneralParameterDescriptor> itm = merged .descriptors().iterator(); verifyParameter(itc.next(), itm.next(), true, null); assertEquals("Missing parameter.", "Parameter B", itc.next().getName().getCode());
/** Helper method that checks if the delegate reader support bands selection. */ private boolean checkIfDelegateReaderSupportsBands() { List<GeneralParameterDescriptor> parameters = delegate.getFormat().getReadParameters().getDescriptor().descriptors(); for (GeneralParameterDescriptor parameterDescriptor : parameters) { if (parameterDescriptor.getName().equals(AbstractGridFormat.BANDS.getName())) { return true; } } return false; }
final Map<String, ?> dummyName = Collections.singletonMap("name", "Test"); for (final OperationMethod method : methods) { final String classification = method.getName().getCode(); final ParameterValueGroup param = mtFactory.getDefaultParameters(classification); try { param.parameter("semi_major").setValue(6377563.396); param.parameter("semi_minor").setValue(6356256.909237285); } catch (IllegalArgumentException e) { assertEquals( classification, ((MapProjection) mt).getParameterDescriptors().getName().getCode()); assertSame(mt, conversion.getMathTransform()); final OperationMethod projMethod = conversion.getMethod(); assertEquals(classification, projMethod.getName().getCode());
/** * Validates the given descriptor. * * @param object The object to validate, or {@code null}. */ public void validate(final ParameterDescriptorGroup object) { if (object == null) { return; } validateIdentifiedObject(object); final List<GeneralParameterDescriptor> descriptors = object.descriptors(); mandatory("ParameterDescriptorGroup: descriptors() should not return null.", descriptors); if (descriptors != null) { for (final GeneralParameterDescriptor descriptor : descriptors) { assertNotNull("ParameterDescriptorGroup: descriptors() can not contain null element.", descriptor); dispatch(descriptor); final GeneralParameterDescriptor byName = object.descriptor(descriptor.getName().getCode()); mandatory("ParameterDescriptorGroup: descriptor(String) should returns a value.", byName); if (byName != null) { assertSame("ParameterDescriptorGroup: descriptor(String) inconsistent with descriptors().", descriptor, byName); } } } final int minOccurs = object.getMinimumOccurs(); assertPositive("ParameterDescriptor: getMinimumOccurs() can not be negative.", minOccurs); assertValidRange("ParameterDescriptor: getMaximumOccurs() gives inconsistent range.", minOccurs, object.getMaximumOccurs()); }
final ImagingParameters copy = (ImagingParameters) descriptor.createValue(); org.geotools.parameter.Parameters.copy(parameters, copy); final ParameterBlockJAI block = (ParameterBlockJAI) copy.parameters; (GridCoverage2D) parameters .parameter(operation.getSourceNames()[PRIMARY_SOURCE_INDEX]) .getValue(); final AffineTransform gridToWorldTransformCorrected = new AffineTransform( final Object roilist = parameters.parameter("roilist").getValue(); o = parameters.parameter("roi").getValue(); } catch (ParameterNotFoundException p) { o = null;
/** * Verify a parameter value. The descriptor is expected to be the same instance than the descriptors * defined in the {@link ParameterValueGroup} and in the {@link OperationMethod}. * * @param method the method of the enclosing operation. * @param group the group which contain the given parameter. * @param expectedValue the expected parameter value. * @param parameter the parameter to verify. */ private static void verifyParameter(final OperationMethod method, final ParameterValueGroup group, final double expectedValue, final ParameterValue<?> parameter) { final ParameterDescriptor<?> descriptor = parameter.getDescriptor(); final String name = descriptor.getName().getCode(); assertSame("parameterValues.descriptor", descriptor, group.getDescriptor().descriptor(name)); assertSame("method.descriptor", descriptor, method.getParameters().descriptor(name)); assertEquals("value", expectedValue, parameter.doubleValue(), STRICT); }
modCount++; final GeneralParameterDescriptor type = parameter.getDescriptor(); final List<GeneralParameterDescriptor> descriptors = descriptor.descriptors(); final String name = type.getName().getCode(); if (!descriptors.contains(type)) { value = ((ParameterValue) parameter).getValue(); } else { value = "(group)"; Errors.format(ErrorKeys.ILLEGAL_ARGUMENT_$2, name, value), name); final int max = type.getMaximumOccurs(); if (max == 1) {
@Override public ParameterValueGroup getReadParameters() { HashMap<String, String> info = new HashMap<String, String>(); info.put("name", getName()); info.put("description", getDescription()); info.put("vendor", getVendor()); info.put("docURL", getDocURL()); info.put("version", getVersion()); List<GeneralParameterDescriptor> delegateFormatParams = new ArrayList<GeneralParameterDescriptor>(); delegateFormatParams.addAll( delegateFormat.getReadParameters().getDescriptor().descriptors()); // add bands parameter descriptor only if the delegate reader doesn't have it // already if (!checkIfDelegateReaderSupportsBands()) { delegateFormatParams.add(AbstractGridFormat.BANDS); } return new ParameterGroup( new DefaultParameterDescriptorGroup( info, delegateFormatParams.toArray( new GeneralParameterDescriptor [delegateFormatParams.size()]))); }