org.apache.pdfbox.pdmodel.graphics.shading.CoonsPatch Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pdfbox Show documentation
Show all versions of pdfbox Show documentation
The Apache PDFBox library is an open source Java tool for working with PDF documents.
/*
* Copyright 2014 The Apache Software Foundation.
*
* Licensed 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.pdfbox.pdmodel.graphics.shading;
import java.awt.geom.Point2D;
import java.util.List;
/**
* This class is used to describe a patch for type 6 shading. This was done as
* part of GSoC2014, Tilman Hausherr is the mentor.
*
* @author Shaola Ren
*/
class CoonsPatch extends Patch
{
/**
* Constructor of a patch for type 6 shading.
*
* @param points 12 control points
* @param color 4 corner colors
*/
protected CoonsPatch(Point2D[] points, float[][] color)
{
super(points, color);
controlPoints = reshapeControlPoints(points);
level = calcLevel();
listOfTriangles = getTriangles();
}
// adjust the 12 control points to 4 groups, each group defines one edge of a patch
private Point2D[][] reshapeControlPoints(Point2D[] points)
{
Point2D[][] fourRows = new Point2D[4][4];
fourRows[2] = new Point2D[]
{
points[0], points[1], points[2], points[3]
}; // d1
fourRows[1] = new Point2D[]
{
points[3], points[4], points[5], points[6]
}; // c2
fourRows[3] = new Point2D[]
{
points[9], points[8], points[7], points[6]
}; // d2
fourRows[0] = new Point2D[]
{
points[0], points[11], points[10], points[9]
}; // c1
return fourRows;
}
// calculate the dividing level from control points
private int[] calcLevel()
{
int[] l =
{
4, 4
};
// if two opposite edges are both lines, there is a possibility to reduce the dividing level
if (isEdgeALine(controlPoints[0]) && isEdgeALine(controlPoints[1]))
{
double lc1 = getLen(controlPoints[0][0], controlPoints[0][3]),
lc2 = getLen(controlPoints[1][0], controlPoints[1][3]);
// determine the dividing level by the lengths of edges
if (lc1 > 800 || lc2 > 800)
{
// keeps init value 4
}
else if (lc1 > 400 || lc2 > 400)
{
l[0] = 3;
}
else if (lc1 > 200 || lc2 > 200)
{
l[0] = 2;
}
else
{
l[0] = 1;
}
}
// the other two opposite edges
if (isEdgeALine(controlPoints[2]) && isEdgeALine(controlPoints[3]))
{
double ld1 = getLen(controlPoints[2][0], controlPoints[2][3]),
ld2 = getLen(controlPoints[3][0], controlPoints[3][3]);
if (ld1 > 800 || ld2 > 800)
{
// keeps init value 4
}
else if (ld1 > 400 || ld2 > 400)
{
l[1] = 3;
}
else if (ld1 > 200 || ld2 > 200)
{
l[1] = 2;
}
else
{
l[1] = 1;
}
}
return l;
}
// get a list of triangles which compose this coons patch
private List getTriangles()
{
// 4 edges are 4 cubic Bezier curves
CubicBezierCurve eC1 = new CubicBezierCurve(controlPoints[0], level[0]);
CubicBezierCurve eC2 = new CubicBezierCurve(controlPoints[1], level[0]);
CubicBezierCurve eD1 = new CubicBezierCurve(controlPoints[2], level[1]);
CubicBezierCurve eD2 = new CubicBezierCurve(controlPoints[3], level[1]);
CoordinateColorPair[][] patchCC = getPatchCoordinatesColor(eC1, eC2, eD1, eD2);
return getShadedTriangles(patchCC);
}
@Override
protected Point2D[] getFlag1Edge()
{
return controlPoints[1].clone();
}
@Override
protected Point2D[] getFlag2Edge()
{
Point2D[] implicitEdge = new Point2D[4];
implicitEdge[0] = controlPoints[3][3];
implicitEdge[1] = controlPoints[3][2];
implicitEdge[2] = controlPoints[3][1];
implicitEdge[3] = controlPoints[3][0];
return implicitEdge;
}
@Override
protected Point2D[] getFlag3Edge()
{
Point2D[] implicitEdge = new Point2D[4];
implicitEdge[0] = controlPoints[0][3];
implicitEdge[1] = controlPoints[0][2];
implicitEdge[2] = controlPoints[0][1];
implicitEdge[3] = controlPoints[0][0];
return implicitEdge;
}
/*
dividing a patch into a grid, return a matrix of the coordinate and color at the crossing points of the grid,
the rule to calculate the coordinate is defined in page 195 of PDF32000_2008.pdf, the rule to calculate the
cooresponding color is bilinear interpolation
*/
private CoordinateColorPair[][] getPatchCoordinatesColor(CubicBezierCurve c1, CubicBezierCurve c2, CubicBezierCurve d1, CubicBezierCurve d2)
{
Point2D[] curveC1 = c1.getCubicBezierCurve();
Point2D[] curveC2 = c2.getCubicBezierCurve();
Point2D[] curveD1 = d1.getCubicBezierCurve();
Point2D[] curveD2 = d2.getCubicBezierCurve();
int numberOfColorComponents = cornerColor[0].length;
int szV = curveD1.length;
int szU = curveC1.length;
CoordinateColorPair[][] patchCC = new CoordinateColorPair[szV][szU];
double stepV = (double) 1 / (szV - 1);
double stepU = (double) 1 / (szU - 1);
double v = -stepV;
for (int i = 0; i < szV; i++)
{
// v and u are the assistant parameters
v += stepV;
double u = -stepU;
for (int j = 0; j < szU; j++)
{
u += stepU;
double scx = (1 - v) * curveC1[j].getX() + v * curveC2[j].getX();
double scy = (1 - v) * curveC1[j].getY() + v * curveC2[j].getY();
double sdx = (1 - u) * curveD1[i].getX() + u * curveD2[i].getX();
double sdy = (1 - u) * curveD1[i].getY() + u * curveD2[i].getY();
double sbx = (1 - v) * ((1 - u) * controlPoints[0][0].getX() + u * controlPoints[0][3].getX())
+ v * ((1 - u) * controlPoints[1][0].getX() + u * controlPoints[1][3].getX());
double sby = (1 - v) * ((1 - u) * controlPoints[0][0].getY() + u * controlPoints[0][3].getY())
+ v * ((1 - u) * controlPoints[1][0].getY() + u * controlPoints[1][3].getY());
double sx = scx + sdx - sbx;
double sy = scy + sdy - sby;
// the above code in this for loop defines the patch surface (coordinates)
Point2D tmpC = new Point2D.Double(sx, sy);
float[] paramSC = new float[numberOfColorComponents];
for (int ci = 0; ci < numberOfColorComponents; ci++)
{
paramSC[ci] = (float) ((1 - v) * ((1 - u) * cornerColor[0][ci] + u * cornerColor[3][ci])
+ v * ((1 - u) * cornerColor[1][ci] + u * cornerColor[2][ci])); // bilinear interpolation
}
patchCC[i][j] = new CoordinateColorPair(tmpC, paramSC);
}
}
return patchCC;
}
}