/*
* 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.Arrays;
import java.util.List;
import org.apache.fop.pdf.PDFDeviceColorSpace;
import org.apache.fop.render.gradient.GradientMaker.DoubleFormatter;
public class Shading {
public interface FunctionRenderer {
void outputFunction(StringBuilder out);
}
/**
* Required: The Type of shading (1,2,3,4,5,6,7)
*/
private final int shadingType;
/**
* A ColorSpace representing the colorspace. "DeviceRGB" is an example.
*/
private final PDFDeviceColorSpace colorSpace;
/**
* Required for Type 2: An Array of four numbers specifying
* the starting and ending coordinate pairs
* Required for Type 3: An Array of six numbers [x0,y0,r0,x1,y1,r1]
* specifying the centers and radii of
* the starting and ending circles.
*/
private final List<Double> coords;
/**
* Required for Type 1, 2, and 3:
* The object of the color mapping function (usually type 2 or 3).
* Optional for Type 4,5,6, and 7: When it's nearly the same thing.
*/
private final Function function;
/**
* Required for Type 2+3: An Array of two boolean values specifying
* whether to extend the start and end colors past the start
* and end points, respectively.
* Default is false, false.
*/
private final List<Boolean> extend;
/**
* Required for Type 4,5,6, and 7: Specifies the number of bits used
* to represent each vertex coordinate.
* Allowed to be 1,2,4,8,12,16,24, or 32.
*/
private final int bitsPerCoordinate;
/**
* Required for Type 4,5,6, and 7: Specifies the number of bits used
* to represent the edge flag for each vertex.
* Allowed to be 2,4,or 8, while the Edge flag itself is allowed to
* be 0,1 or 2.
*/
private final int bitsPerFlag;
/**
* Optional: A flag whether or not to filter the shading function
* to prevent aliasing artifacts. Default is false.
*/
private final boolean antiAlias;
/**
* Required for Type 4,5,6, and 7: Specifies the number of bits used
* to represent each color coordinate.
* Allowed to be 1,2,4,8,12, or 16
*/
private final int bitsPerComponent;
/**
* Required for Type 5:The number of vertices in each "row" of
* the lattice; it must be greater than or equal to 2.
*/
private final int verticesPerRow;
public Shading(int shadingType, PDFDeviceColorSpace colorSpace,
List<Double> coords, Function function) {
this.shadingType = shadingType;
this.colorSpace = colorSpace;
this.antiAlias = false;
this.coords = coords;
this.function = function;
this.extend = Arrays.asList(true, true);
this.bitsPerCoordinate = 0;
this.bitsPerFlag = 0;
this.bitsPerComponent = 0;
this.verticesPerRow = 0;
}
public int getShadingType() {
return shadingType;
}
public PDFDeviceColorSpace getColorSpace() {
return colorSpace;
}
public List<Double> getCoords() {
return coords;
}
public Function getFunction() {
return function;
}
public List<Boolean> getExtend() {
return extend;
}
public int getBitsPerCoordinate() {
return bitsPerCoordinate;
}
public int getBitsPerFlag() {
return bitsPerFlag;
}
public boolean isAntiAlias() {
return antiAlias;
}
public int getBitsPerComponent() {
return bitsPerComponent;
}
public int getVerticesPerRow() {
return verticesPerRow;
}
public void output(StringBuilder out, DoubleFormatter doubleFormatter, FunctionRenderer functionRenderer) {
out.append("<<\n/ShadingType " + shadingType + "\n");
if (colorSpace != null) {
out.append("/ColorSpace /" + colorSpace.getName() + "\n");
}
if (antiAlias) {
out.append("/AntiAlias " + antiAlias + "\n");
}
switch (shadingType) {
// Function based shading
case 1: outputShadingType1(out, doubleFormatter, functionRenderer); break;
// Axial shading
case 2:
// Radial shading
case 3: outputShadingType2or3(out, doubleFormatter, functionRenderer); break;
// Free-form Gouraud-shaded triangle meshes
case 4:
// Coons patch meshes
case 6:
// Tensor product patch meshes
case 7: outputShadingType4or6or7(out, doubleFormatter, functionRenderer); break;
// Lattice Free form gouraud-shaded triangle mesh
case 5: outputShadingType5(out, doubleFormatter, functionRenderer); break;
default: throw new UnsupportedOperationException("Shading type " + shadingType);
}
out.append(">>");
}
private void outputShadingType1(StringBuilder out, DoubleFormatter doubleFormatter,
Shading.FunctionRenderer functionRenderer) {
outputFunction(out, functionRenderer);
}
private void outputShadingType2or3(StringBuilder out, DoubleFormatter doubleFormatter,
Shading.FunctionRenderer functionRenderer) {
if (coords != null) {
out.append("/Coords ");
GradientMaker.outputDoubles(out, doubleFormatter, coords);
out.append("\n");
}
out.append("/Extend [ ");
for (Boolean b : extend) {
out.append(b);
out.append(" ");
}
out.append("]\n");
outputFunction(out, functionRenderer);
}
private void outputShadingType4or6or7(StringBuilder out, DoubleFormatter doubleFormatter,
Shading.FunctionRenderer functionRenderer) {
if (bitsPerCoordinate > 0) {
out.append("/BitsPerCoordinate " + bitsPerCoordinate + "\n");
} else {
out.append("/BitsPerCoordinate 1 \n");
}
if (bitsPerComponent > 0) {
out.append("/BitsPerComponent " + bitsPerComponent + "\n");
} else {
out.append("/BitsPerComponent 1 \n");
}
if (bitsPerFlag > 0) {
out.append("/BitsPerFlag " + bitsPerFlag + "\n");
} else {
out.append("/BitsPerFlag 2 \n");
}
outputFunction(out, functionRenderer);
}
private void outputShadingType5(StringBuilder out, DoubleFormatter doubleFormatter,
Shading.FunctionRenderer functionRenderer) {
if (bitsPerCoordinate > 0) {
out.append("/BitsPerCoordinate " + bitsPerCoordinate + "\n");
} else {
out.append("/BitsPerCoordinate 1 \n");
}
if (bitsPerComponent > 0) {
out.append("/BitsPerComponent " + bitsPerComponent + "\n");
} else {
out.append("/BitsPerComponent 1 \n");
}
outputFunction(out, functionRenderer);
if (verticesPerRow > 0) {
out.append("/VerticesPerRow " + verticesPerRow + "\n");
} else {
out.append("/VerticesPerRow 2 \n");
}
}
private void outputFunction(StringBuilder out, FunctionRenderer functionRenderer) {
if (function != null) {
out.append("/Function ");
functionRenderer.outputFunction(out);
out.append("\n");
}
}
}