use of org.opengis.parameter.ParameterValueGroup in project sis by apache.
the class InverseOperationMethod method properties.
/**
* Infers the properties to give to an inverse coordinate operation.
* The returned map will contains three kind of information:
*
* <ul>
* <li>Metadata (domain of validity, accuracy)</li>
* <li>Parameter values, if possible</li>
* </ul>
*
* This method copies accuracy and domain of validity metadata from the given operation.
* We presume that the inverse operation has the same accuracy than the direct operation.
*
* <div class="note"><b>Note:</b>
* in many cases, the inverse operation is numerically less accurate than the direct operation because it
* uses approximations like series expansions or iterative methods. However the numerical errors caused by
* those approximations are not of interest here, because they are usually much smaller than the inaccuracy
* due to the stochastic nature of coordinate transformations (not to be confused with coordinate conversions;
* see ISO 19111 for more information).</div>
*
* If the inverse of the given operation can be represented by inverting the sign of all numerical
* parameter values, then this method copies also those parameters in a {@code "parameters"} entry.
*
* @param source the operation for which to get the inverse parameters.
* @param target where to store the inverse parameters.
*/
static void properties(final SingleOperation source, final Map<String, Object> target) {
target.put(SingleOperation.DOMAIN_OF_VALIDITY_KEY, source.getDomainOfValidity());
final Collection<PositionalAccuracy> accuracy = source.getCoordinateOperationAccuracy();
if (!Containers.isNullOrEmpty(accuracy)) {
target.put(SingleOperation.COORDINATE_OPERATION_ACCURACY_KEY, accuracy.toArray(new PositionalAccuracy[accuracy.size()]));
}
/*
* If the inverse of the given operation can be represented by inverting the sign of all numerical
* parameter values, copies those parameters in a "parameters" entry in the properties map.
* Otherwise does nothing.
*/
final ParameterValueGroup parameters = source.getParameterValues();
final ParameterValueGroup copy = parameters.getDescriptor().createValue();
for (final GeneralParameterValue gp : parameters.values()) {
if (gp instanceof ParameterValue<?>) {
final ParameterValue<?> src = (ParameterValue<?>) gp;
final Object value = src.getValue();
if (value instanceof Number) {
final ParameterDescriptor<?> descriptor = src.getDescriptor();
final InternationalString remarks = descriptor.getRemarks();
if (remarks != SignReversalComment.SAME) {
if (remarks != SignReversalComment.OPPOSITE) {
/*
* The parameter descriptor does not specify whether the values for the inverse operation
* have the same sign or opposite sign. We could heuristically presume that we can invert
* the sign if the minimum value has the opposite sign than the maximum value (as in the
* [-10 … 10] range), but such assumption is dangerous. For example the values in a matrix
* could be bounded to a range like [-1 … 1], which would mislead above heuristic rule.
*
* Note that abandoning here does not mean that we will never know the parameter values.
* As a fallback, AbstractCoordinateOperation will try to get the parameter values from
* the MathTransform. This is the appropriate thing to do at least for Affine operation.
*/
return;
}
/*
* The parameter value of the inverse operation is (or is presumed to be) the negative of
* the parameter value of the source operation. We need to preserve units of measurement
* if they were specified.
*/
final ParameterValue<?> tgt = copy.parameter(descriptor.getName().getCode());
final Unit<?> unit = src.getUnit();
if (unit != null) {
tgt.setValue(-src.doubleValue(), unit);
} else if (value instanceof Integer || value instanceof Short || value instanceof Byte) {
tgt.setValue(-src.intValue());
} else {
tgt.setValue(-src.doubleValue());
}
// No need to add 'tgt' to 'copy' since it was done by the call to copy.parameter(…).
continue;
}
}
}
copy.values().add(gp);
}
target.put(ReferencingServices.PARAMETERS_KEY, copy);
}
use of org.opengis.parameter.ParameterValueGroup in project sis by apache.
the class WKTUtilities method append.
/**
* Appends a {@linkplain ParameterValue parameter} in a {@code PARAMETER[…]} element.
* If the supplied parameter is actually a {@linkplain ParameterValueGroup parameter group},
* all contained parameters will be flattened in a single list.
*
* @param parameter the parameter to append to the WKT, or {@code null} if none.
* @param formatter the formatter where to append the parameter.
*/
public static void append(GeneralParameterValue parameter, final Formatter formatter) {
if (parameter instanceof ParameterValueGroup) {
boolean first = true;
for (final GeneralParameterValue param : ((ParameterValueGroup) parameter).values()) {
if (first) {
formatter.newLine();
first = false;
}
append(param, formatter);
}
}
if (parameter instanceof ParameterValue<?>) {
if (!(parameter instanceof FormattableObject)) {
parameter = new DefaultParameterValue<>((ParameterValue<?>) parameter);
}
formatter.append((FormattableObject) parameter);
formatter.newLine();
}
}
use of org.opengis.parameter.ParameterValueGroup in project sis by apache.
the class CC_OperationMethod method store.
/**
* Stores the given {@code parameters} into the given {@code addTo} collection.
* This method copies only the <em>references</em> if possible. However is some
* cases the values may need to be copied in new parameter instances.
*
* <div class="note"><b>Note:</b>
* this code is defined in this {@code CC_OperationMethod} class instead than in the
* {@link DefaultOperationMethod} class in the hope to reduce the amount of code processed
* by the JVM in the common case where JAXB (un)marshalling is not needed.</div>
*
* @param parameters the parameters to add to the {@code addTo} collection.
* @param addTo where to store the {@code parameters}.
* @param replacements the replacements to apply in the {@code GeneralParameterValue} instances.
*/
public static void store(final GeneralParameterValue[] parameters, final Collection<GeneralParameterValue> addTo, final Map<GeneralParameterDescriptor, GeneralParameterDescriptor> replacements) {
for (GeneralParameterValue p : parameters) {
final GeneralParameterDescriptor replacement = replacements.get(p.getDescriptor());
if (replacement != null) {
if (p instanceof ParameterValue<?>) {
final ParameterValue<?> source = (ParameterValue<?>) p;
final ParameterValue<?> target = new DefaultParameterValue<>((ParameterDescriptor<?>) replacement);
final Object value = source.getValue();
final Unit<?> unit = source.getUnit();
if (unit == null) {
target.setValue(value);
} else if (value instanceof double[]) {
target.setValue((double[]) value, unit);
} else {
target.setValue(((Number) value).doubleValue(), unit);
}
p = target;
} else if (p instanceof ParameterValueGroup) {
final ParameterValueGroup source = (ParameterValueGroup) p;
final ParameterValueGroup target = new DefaultParameterValueGroup((ParameterDescriptorGroup) replacement);
final Collection<GeneralParameterValue> values = source.values();
store(values.toArray(new GeneralParameterValue[values.size()]), target.values(), replacements);
p = target;
}
}
addTo.add(p);
}
}
use of org.opengis.parameter.ParameterValueGroup in project sis by apache.
the class Affine method identity.
/**
* Returns parameter values for an identity transform of the given input and output dimensions.
* Callers can modify the returned parameters if desired.
*
* @param dimension the number of source and target dimensions.
* @return parameters for an identity transform of the given dimensions.
*
* @since 0.8
*/
public static ParameterValueGroup identity(int dimension) {
final ParameterValueGroup values = TensorParameters.WKT1.createValueGroup(Collections.singletonMap(NAME_KEY, Constants.AFFINE));
values.parameter(Constants.NUM_COL).setValue(++dimension);
values.parameter(Constants.NUM_ROW).setValue(dimension);
return values;
}
use of org.opengis.parameter.ParameterValueGroup in project sis by apache.
the class TensorValuesTest method testAlphaNumericDescriptors.
/**
* Tests {@link TensorValues#descriptors()} using alphanumeric (EPSG) contentions.
*/
@Test
@DependsOnMethod("testDescriptors")
public void testAlphaNumericDescriptors() {
final Double N0 = 0.0;
final Double N1 = 1.0;
final Integer N3 = 3;
final ParameterValueGroup group = createAlphaNumeric();
final List<GeneralParameterDescriptor> descriptors = group.getDescriptor().descriptors();
assertDescriptorEquals(NUM_ROW, N3, descriptors.get(0));
assertDescriptorEquals(NUM_COL, N3, descriptors.get(1));
assertDescriptorEquals("A0", N1, descriptors.get(2));
assertDescriptorEquals("A1", N0, descriptors.get(3));
assertDescriptorEquals("A2", N0, descriptors.get(4));
assertDescriptorEquals("B0", N0, descriptors.get(5));
assertDescriptorEquals("B1", N1, descriptors.get(6));
assertDescriptorEquals("B2", N0, descriptors.get(7));
assertDescriptorEquals("C0", N0, descriptors.get(8));
assertDescriptorEquals("C1", N0, descriptors.get(9));
assertDescriptorEquals("C2", N1, descriptors.get(10));
assertEquals("size", 11, descriptors.size());
}
Aggregations