org.apache.fop.render.gradient.Function Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.apache.fop Show documentation
Show all versions of org.apache.fop Show documentation
The core maven build properties
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.fop.render.gradient;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.apache.fop.render.gradient.GradientMaker.DoubleFormatter;
public class Function {
public interface SubFunctionRenderer {
void outputFunction(StringBuilder out, int functionIndex);
}
/**
* Required: The Type of function (0,2,3,4) default is 0.
*/
private int functionType;
/**
* Required: 2 * m Array of Double numbers which are possible inputs to the function
*/
private List domain;
/**
* Required: 2 * n Array of Double numbers which are possible outputs to the function
*/
private List range;
/**
* Required for Type 0: Number of Bits used to represent each sample value.
* Limited to 1,2,4,8,12,16,24, or 32
*/
private int bitsPerSample = 1;
/**
* Optional for Type 0: order of interpolation between samples.
* Limited to linear (1) or cubic (3). Default is 1
*/
private int order = 1;
/**
* Optional for Type 0: A 2 * m array of Doubles which provides a
* linear mapping of input values to the domain.
*
* Required for Type 3: A 2 * k array of Doubles that, taken
* in pairs, map each subset of the domain defined by Domain
* and the Bounds array to the domain of the corresponding function.
* Should be two values per function, usually (0,1),
* as in [0 1 0 1] for 2 functions.
*/
private List encode;
/* *************************TYPE 2************************** */
/**
* Required For Type 2: An Array of n Doubles defining
* the function result when x=0. Default is [0].
*/
private float[] cZero;
/**
* Required For Type 2: An Array of n Doubles defining
* the function result when x=1. Default is [1].
*/
private float[] cOne;
/**
* Required for Type 2: The interpolation exponent.
* Each value x will return n results.
* Must be greater than 0.
*/
private double interpolationExponentN = 1;
/* *************************TYPE 3************************** */
/**
* Required for Type 3: An vector of PDFFunctions which
* form an array of k single input functions making up
* the stitching function.
*/
private List functions;
/**
* Optional for Type 3: An array of (k-1) Doubles that,
* in combination with Domain, define the intervals to which
* each function from the Functions array apply. Bounds
* elements must be in order of increasing magnitude,
* and each value must be within the value of Domain.
* k is the number of functions.
* If you pass null, it will output (1/k) in an array of k-1 elements.
* This makes each function responsible for an equal amount of the stitching function.
* It makes the gradient even.
*/
private List bounds;
private byte[] datasource;
private List size;
/**
* create an complete Function object of Type 2, an Exponential Interpolation function.
*
* Use null for an optional object parameter if you choose not to use it.
* For optional int parameters, pass the default.
* @param domain List objects of Double objects.
* This is the domain of the function.
* See page 264 of the PDF 1.3 Spec.
* @param range List of Doubles that is the Range of the function.
* See page 264 of the PDF 1.3 Spec.
* @param cZero This is a vector of Double objects which defines the function result
* when x=0.
*
* This attribute is optional.
* It's described on page 268 of the PDF 1.3 spec.
* @param cOne This is a vector of Double objects which defines the function result
* when x=1.
*
* This attribute is optional.
* It's described on page 268 of the PDF 1.3 spec.
* @param interpolationExponentN This is the inerpolation exponent.
*
* This attribute is required.
* PDF Spec page 268
*/
public Function(List domain, List range, float[] cZero, float[] cOne,
double interpolationExponentN) {
this(2, domain, range);
this.cZero = cZero;
this.cOne = cOne;
this.interpolationExponentN = interpolationExponentN;
}
/**
* create an complete Function object of Type 3, a Stitching function.
*
* Use null for an optional object parameter if you choose not to use it.
* For optional int parameters, pass the default.
* @param domain List objects of Double objects.
* This is the domain of the function.
* See page 264 of the PDF 1.3 Spec.
* @param range List objects of Double objects.
* This is the Range of the function.
* See page 264 of the PDF 1.3 Spec.
* @param functions A List of the PDFFunction objects that the stitching function stitches.
*
* This attributed is required.
* It is described on page 269 of the PDF spec.
* @param bounds This is a vector of Doubles representing the numbers that,
* in conjunction with Domain define the intervals to which each function from
* the 'functions' object applies. It must be in order of increasing magnitude,
* and each must be within Domain.
*
* It basically sets how much of the gradient each function handles.
*
* This attributed is required.
* It's described on page 269 of the PDF 1.3 spec.
* @param encode List objects of Double objects.
* This is the linear mapping of input values intop the domain
* of the function's sample table. Default is hard to represent in
* ascii, but basically [0 (Size0 1) 0 (Size1 1)...].
* This attribute is required.
*
* See page 270 in the PDF 1.3 spec.
*/
public Function(List domain, List range, List functions,
List bounds, List encode) {
this(3, domain, range);
this.functions = functions;
this.bounds = bounds;
this.encode = makeEncode(encode);
}
public void setCZero(float[] cZero) {
this.cZero = cZero;
}
public void setCOne(float[] cOne) {
this.cOne = cOne;
}
private List makeEncode(List encode) {
if (encode != null) {
return encode;
} else {
encode = new ArrayList(functions.size() * 2);
for (int i = 0; i < functions.size(); i++) {
encode.add(0.0);
encode.add(1.0);
}
return encode;
}
}
private Function(int functionType, List domain, List range) {
this.functionType = functionType;
this.domain = (domain == null) ? Arrays.asList(0.0, 1.0) : domain;
this.range = range;
}
public Function(List domain, List range, List encode, byte[] datasource, int bitsPerSample,
List size) {
this(0, domain, range);
this.encode = encode;
this.datasource = datasource;
this.bitsPerSample = bitsPerSample;
this.size = size;
}
/**
* Gets the function type
*/
public int getFunctionType() {
return functionType;
}
/**
* Gets the function bounds
*/
public List getBounds() {
return bounds;
}
/**
* The function domain
*/
public List getDomain() {
return domain;
}
/**
* Gets the function encoding
*/
public List getEncode() {
return encode;
}
/**
* Gets the sub-functions
*/
public List getFunctions() {
if (functions == null) {
return Collections.emptyList();
} else {
return functions;
}
}
/**
* Gets the bits per sample of the function
*/
public int getBitsPerSample() {
return bitsPerSample;
}
/**
* Gets the interpolation exponent of the function
*/
public double getInterpolationExponentN() {
return interpolationExponentN;
}
/**
* Gets the function order
*/
public int getOrder() {
return order;
}
/**
* Gets the function range
*/
public List getRange() {
return range;
}
/**
* Gets the function C0 value (color for gradient)
*/
public float[] getCZero() {
return cZero;
}
/**
* Gets the function C1 value (color for gradient)
*/
public float[] getCOne() {
return cOne;
}
public String output(StringBuilder out, DoubleFormatter doubleFormatter,
SubFunctionRenderer subFunctionRenderer) {
out.append("<<\n/FunctionType " + functionType + "\n");
outputDomain(out, doubleFormatter);
if (this.functionType == 0) {
outputEncode(out, doubleFormatter);
outputBitsPerSample(out);
outputOrder(out);
outputRange(out, doubleFormatter);
out.append("\n/DataSource <");
for (byte b : datasource) {
out.append(String.format("%02x", b & 0xff));
}
out.append(">\n");
out.append("/Size [");
for (Integer i : size) {
out.append(i);
out.append(" ");
}
out.append("]\n");
out.append(">>");
} else if (functionType == 2) {
outputRange(out, doubleFormatter);
outputCZero(out, doubleFormatter);
outputCOne(out, doubleFormatter);
outputInterpolationExponentN(out, doubleFormatter);
out.append(">>");
} else if (functionType == 3) {
outputRange(out, doubleFormatter);
if (!functions.isEmpty()) {
out.append("/Functions [ ");
for (int i = 0; i < functions.size(); i++) {
subFunctionRenderer.outputFunction(out, i);
out.append(' ');
}
out.append("]\n");
}
outputEncode(out, doubleFormatter);
out.append("/Bounds ");
if (bounds != null) {
GradientMaker.outputDoubles(out, doubleFormatter, bounds);
} else if (!functions.isEmpty()) {
// if there are n functions,
// there must be n-1 bounds.
// so let each function handle an equal portion
// of the whole. e.g. if there are 4, then [ 0.25 0.25 0.25 ]
int numberOfFunctions = functions.size();
String functionsFraction = doubleFormatter.formatDouble(1.0 / numberOfFunctions);
out.append("[ ");
for (int i = 0; i + 1 < numberOfFunctions; i++) {
out.append(functionsFraction);
out.append(" ");
}
out.append("]");
}
out.append("\n>>");
} else if (functionType == 4) {
outputRange(out, doubleFormatter);
out.append(">>");
}
return out.toString();
}
private void outputDomain(StringBuilder p, DoubleFormatter doubleFormatter) {
p.append("/Domain ");
GradientMaker.outputDoubles(p, doubleFormatter, domain);
p.append("\n");
}
private void outputBitsPerSample(StringBuilder out) {
out.append("/BitsPerSample " + bitsPerSample + "\n");
}
private void outputOrder(StringBuilder out) {
if (order == 1 || order == 3) {
out.append("\n/Order " + order + "\n");
}
}
private void outputRange(StringBuilder out, DoubleFormatter doubleFormatter) {
if (range != null) {
out.append("/Range ");
GradientMaker.outputDoubles(out, doubleFormatter, range);
out.append("\n");
}
}
private void outputEncode(StringBuilder out, DoubleFormatter doubleFormatter) {
out.append("/Encode ");
GradientMaker.outputDoubles(out, doubleFormatter, encode);
out.append("\n");
}
private void outputCZero(StringBuilder out, DoubleFormatter doubleFormatter) {
if (cZero != null) {
out.append("/C0 [ ");
for (float c : cZero) {
out.append(doubleFormatter.formatDouble(c));
out.append(" ");
}
out.append("]\n");
}
}
private void outputCOne(StringBuilder out, DoubleFormatter doubleFormatter) {
if (cOne != null) {
out.append("/C1 [ ");
for (float c : cOne) {
out.append(doubleFormatter.formatDouble(c));
out.append(" ");
}
out.append("]\n");
}
}
private void outputInterpolationExponentN(StringBuilder out, DoubleFormatter doubleFormatter) {
out.append("/N ");
out.append(doubleFormatter.formatDouble(interpolationExponentN));
out.append("\n");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy