public void translate(double dx, double dy) {
for (ConvexPolygonalZone.HalfPlane hp : convexPolygonalZone) hp.getOrg().translate(dx, dy);
if (allocationIntersectionPath0 == null) {
// ici la zone convexe ne coupe pas le bord du PECanvas donc on
// translate son contour tout bêtement. Il se peut que le résultat
// se mette à couper le PECanvas, dans ce cas le tireté à la
// coupure ne sera pas affiché.
if (boundaryPath0 != null) {
AffineTransform at;
boundaryPath0.transform(at = new AffineTransform(1.0, 0.0, 0.0, 1.0, dx, dy));
if (boundaryPath1 != null) boundaryPath1.transform(at);
}
} else {
// ici la zone convexe coupe le bord du PECanvas donc on recalcule
// brutalement les formes constituant sa vue.
boundaryPath0 = null;
}
// toutefois on essaie de conserver le calcul de la frontière
if (boundary != null) for (PicPoint pt : boundary.subdivisionPoints) pt.translate(dx, dy);
}
public void scale(PicPoint pt, double dx, double dy) {
for (ConvexPolygonalZone.HalfPlane hp : convexPolygonalZone) {
hp.getOrg().scale(pt, dx, dy);
hp.getDir().scale(dx, dy);
}
}
public void scale(double x, double y, double dx, double dy) {
for (ConvexPolygonalZone.HalfPlane hp : convexPolygonalZone) {
hp.getOrg().scale(x, y, dx, dy);
hp.getDir().scale(dx, dy);
}
}
public void rotate(PicPoint org, double angle) {
for (ConvexPolygonalZone.HalfPlane hp : convexPolygonalZone) {
hp.getOrg().rotate(org, angle);
hp.getDir().rotate(angle);
}
}
public void shear(PicPoint pt, double shx, double shy) {
for (ConvexPolygonalZone.HalfPlane hp : convexPolygonalZone) {
hp.getOrg().shear(pt, shx, shy);
hp.getDir().scale(shx, shy);
}
}
/**
* Renvoie le point le plus loin de l'origine d'une demi-droite coupant le rectangle
* d'allocation passé à la construction de <code>this</code>. La demi-droite est déterminée
* comme l'une des demi-bordure d'un <code>ConvexPolygonalZone.HalfPlane</code> selon selon
* l'argument <code>direction</code>.
*
* @param hp une valeur <code>ConvexPolygonalZone.HalfPlane</code> déterminant l'une ou l'autre
* des demi-droite frontière du demi-plan de part et d'autre de son point d'origine.
* @param direction une valeur <code>double</code> égale à +1 ou -1, selectionnant la bonne des
* deux demi-droites.
* @return une valeur <code>PicPoint</code>
*/
PicPoint get(ConvexPolygonalZone.HalfPlane hp, double direction) {
double nx, ny, ux, uy, ox, oy;
nx = hp.getDir().getX();
ny = hp.getDir().getY();
ux = direction * ny;
uy = direction * -nx;
ox = hp.getOrg().getX();
oy = hp.getOrg().getY();
// on cherche le point d'intersection entre la bordure de la zone
// convexe et la bordure du PECanvas sous la forme de
// o + lambda * u, avec o = (ox, oy) et u = (ux, uy)
double lambdaX, lambdaY, lambda;
int xMap = 0;
int yMap = 0;
int shiftLeft = 2 * anglePointNb++;
if (ux != 0.0) {
lambdaX = (x0 - ox) / ux;
lambda = (x1 - ox) / ux;
if (lambda > lambdaX) {
// la bordure verticale de *droite* du PECanvas est celle
// qui est du bon côté
lambdaX = lambda;
xMap = 3;
} else
// la bordure verticale de *gauche* du PECanvas est celle
// qui est du bon côté
xMap = 1;
} else {
lambdaX = Double.POSITIVE_INFINITY;
xMap = 2;
}
if (uy != 0.0) {
lambdaY = (y0 - oy) / uy;
lambda = (y1 - oy) / uy;
if (lambda > lambdaY) {
// la bordure verticale du *haut* du PECanvas est celle
// qui est du bon côté
lambdaY = lambda;
yMap = 3;
} else
// la bordure verticale du *bas* du PECanvas est celle
// qui est du bon côté
yMap = 1;
} else {
lambdaY = Double.POSITIVE_INFINITY;
yMap = 2;
}
if (lambdaY > lambdaX) {
// la bordure de zone convexe coupe une bordure *verticale* de
// PECanvas en premier
lambda = lambdaX;
if (ny * (yMap - 2) < 0) yMap = 4 - yMap;
} else {
// la bordure de zone convexe coupe une bordure *horizontale*
// de PECanvas en premier
lambda = lambdaY;
if (nx * (xMap - 2) < 0) xMap = 4 - xMap;
}
this.xMap |= xMap << shiftLeft;
this.yMap |= yMap << shiftLeft;
return new PicPoint(ox + lambda * ux, oy + lambda * uy);
}