/*
* 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<ShadedTriangle> 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;
}
}