public void paintComponent(Graphics g) {
super.paintComponent(g);
int xCenter = getSize().width / 2;
int yCenter = getSize().height / 2;
int radius = (int) (Math.min(getSize().width, getSize().height) * 0.4);
// Create a Polygon object
Polygon polygon = new Polygon();
// Add points to the polygon
polygon.addPoint(xCenter + radius, yCenter);
polygon.addPoint(
(int) (xCenter + radius * Math.cos(2 * Math.PI / 6)),
(int) (yCenter - radius * Math.sin(2 * Math.PI / 6)));
polygon.addPoint(
(int) (xCenter + radius * Math.cos(2 * 2 * Math.PI / 6)),
(int) (yCenter - radius * Math.sin(2 * 2 * Math.PI / 6)));
polygon.addPoint(
(int) (xCenter + radius * Math.cos(3 * 2 * Math.PI / 6)),
(int) (yCenter - radius * Math.sin(3 * 2 * Math.PI / 6)));
polygon.addPoint(
(int) (xCenter + radius * Math.cos(4 * 2 * Math.PI / 6)),
(int) (yCenter - radius * Math.sin(4 * 2 * Math.PI / 6)));
polygon.addPoint(
(int) (xCenter + radius * Math.cos(5 * 2 * Math.PI / 6)),
(int) (yCenter - radius * Math.sin(5 * 2 * Math.PI / 6)));
// Draw the polygon
g.drawPolygon(polygon);
}
/**
* Paint the clock
*
* @param c a component
* @param g graphic object
* @param x
* @param y
*/
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g;
Ellipse2D.Double circle = new Ellipse2D.Double();
circle.setFrameFromCenter(250, 250, 400, 400);
g2.draw(circle);
Line2D.Double hHand =
new Line2D.Double(
250,
250,
250 + HOUR_HAND_LENGTH * Math.sin(Math.PI * (double) hour / 6),
250 - HOUR_HAND_LENGTH * Math.cos(Math.PI * (double) hour / 6));
Line2D.Double mHand =
new Line2D.Double(
250,
250,
250 + MIN_HAND_LENGTH * Math.sin(Math.PI * (double) min / 30),
250 - MIN_HAND_LENGTH * Math.cos(Math.PI * (double) min / 30));
Line2D.Double sHand =
new Line2D.Double(
250,
250,
250 + SEC_HAND_LENGTH * Math.sin(Math.PI * (double) sec / 30),
250 - SEC_HAND_LENGTH * Math.cos(Math.PI * (double) sec / 30));
g2.draw(hHand);
g2.draw(mHand);
g2.draw(sHand);
}
private void drawArrow(Graphics2D g2, double theta, double x0, double y0) {
double x = x0 - barb * Math.cos(theta + phi);
double y = y0 - barb * Math.sin(theta + phi);
g2.draw(new Line2D.Double(x0, y0, x, y));
x = x0 - barb * Math.cos(theta - phi);
y = y0 - barb * Math.sin(theta - phi);
g2.draw(new Line2D.Double(x0, y0, x, y));
}
/**
* Draws an open star with a specified number of points.<br>
* The center of this star is specified by centerX,centerY and its size is specified by radius
* <br>
* (As in the radius of the circle the star would fit inside). <br>
* Precondition: points >= 2 <br>
* Example: <br>
* Expo.drawStar(g,300,200,100,8); <br>
* Draws an open star with 8 points and a radius of 100 pixels whose center is located at the
* coordinate (300,200).
*/
public static void drawStar(Graphics g, int centerX, int centerY, int radius, int points) {
int halfRadius = getHalfRadius(radius, points);
int p = points;
points *= 2;
int xCoord[] = new int[points];
int yCoord[] = new int[points];
int currentRadius;
for (int k = 0; k < points; k++) {
if (k % 2 == 0) currentRadius = radius;
else currentRadius = halfRadius;
xCoord[k] = (int) Math.round(Math.cos(twoPI * k / points - halfPI) * currentRadius) + centerX;
yCoord[k] = (int) Math.round(Math.sin(twoPI * k / points - halfPI) * currentRadius) + centerY;
}
int x = (p - 5) / 2 + 1;
if (p >= 5 && p <= 51)
switch (p % 4) {
case 1:
yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x];
break;
case 2:
yCoord[x] = yCoord[x + 1] = yCoord[points - x - 1] = yCoord[points - x];
yCoord[x + 3] = yCoord[x + 4] = yCoord[points - x - 4] = yCoord[points - x - 3];
break;
case 3:
yCoord[x + 2] = yCoord[x + 3] = yCoord[points - x - 3] = yCoord[points - x - 2];
}
g.drawPolygon(xCoord, yCoord, points);
}
public static void main(String[] args) {
Plot2DPanel p2 = new Plot2DPanel();
double[][] XYZ = new double[100][2];
for (int j = 0; j < XYZ.length; j++) {
XYZ[j][0] = 2 * Math.PI * (double) j / XYZ.length;
XYZ[j][1] = Math.sin(XYZ[j][0]);
}
double[][] XYZ2 = new double[100][2];
for (int j = 0; j < XYZ2.length; j++) {
XYZ2[j][0] = 2 * Math.PI * (double) j / XYZ.length;
XYZ2[j][1] = Math.sin(2 * XYZ2[j][0]);
}
p2.addLinePlot("sin", Color.RED, AbstractDrawer.DOTTED_LINE, XYZ);
p2.setBackground(new Color(200, 0, 0));
p2.addLinePlot("sin2", Color.BLUE, AbstractDrawer.CROSS_DOT, XYZ2);
p2.setLegendOrientation(PlotPanel.SOUTH);
new FrameView(p2).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
Plot3DPanel p = new Plot3DPanel();
XYZ = new double[100][3];
for (int j = 0; j < XYZ.length; j++) {
XYZ[j][0] = 2 * Math.PI * (double) j / XYZ.length;
XYZ[j][1] = Math.sin(XYZ[j][0]);
XYZ[j][2] = Math.sin(XYZ[j][0]) * Math.cos(XYZ[j][1]);
}
p.addLinePlot("toto", XYZ);
p.setLegendOrientation(PlotPanel.SOUTH);
new FrameView(p).setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
}
void draw(Graphics2D g) {
g.setColor(darkColor);
int x = (int) (center_x + distance * Math.sin(-unit * current / num));
int y = (int) (center_y + distance * Math.cos(-unit * current / num));
Area area = new Area(new Ellipse2D.Double(x, y, ball_r, ball_r));
g.fill(area);
}
public static double[][] initialisationXy(
double[][] xy, double pasCircu, double R, double[] teta) {
int i = 0;
while (i < xy.length) {
xy[i][0] = R * Math.cos(teta[i]) + R;
xy[i][1] = R * Math.sin(teta[i]);
i++;
}
return xy;
}
@Override
/** Draw the clock */
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// Initialize clock parameters
int clockRadius = (int) (Math.min(getWidth(), getHeight()) * 0.8 * 0.5);
int xCenter = getWidth() / 2;
int yCenter = getHeight() / 2;
// Draw circle
g.setColor(Color.black);
g.drawOval(xCenter - clockRadius, yCenter - clockRadius, 2 * clockRadius, 2 * clockRadius);
g.drawString("12", xCenter - 5, yCenter - clockRadius + 12);
g.drawString("9", xCenter - clockRadius + 3, yCenter + 5);
g.drawString("3", xCenter + clockRadius - 10, yCenter + 3);
g.drawString("6", xCenter - 3, yCenter + clockRadius - 3);
// Draw second hand
int sLength = (int) (clockRadius * 0.8);
int xSecond = (int) (xCenter + sLength * Math.sin(second * (2 * Math.PI / 60)));
int ySecond = (int) (yCenter - sLength * Math.cos(second * (2 * Math.PI / 60)));
g.setColor(Color.red);
g.drawLine(xCenter, yCenter, xSecond, ySecond);
// Draw minute hand
int mLength = (int) (clockRadius * 0.65);
int xMinute = (int) (xCenter + mLength * Math.sin(minute * (2 * Math.PI / 60)));
int yMinute = (int) (yCenter - mLength * Math.cos(minute * (2 * Math.PI / 60)));
g.setColor(Color.blue);
g.drawLine(xCenter, yCenter, xMinute, yMinute);
// Draw hour hand
int hLength = (int) (clockRadius * 0.5);
int xHour =
(int) (xCenter + hLength * Math.sin((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
int yHour =
(int) (yCenter - hLength * Math.cos((hour % 12 + minute / 60.0) * (2 * Math.PI / 12)));
g.setColor(Color.green);
g.drawLine(xCenter, yCenter, xHour, yHour);
}
public void calc() {
try {
// 取得輸入區的字串, 轉成浮點數後除以角度換算單位
double theta = Double.parseDouble(degree.getText()) / convert;
// 計算三角函數值, 並將結果寫到各文字欄位中
sintxt.setText(String.format("%.3f", Math.sin(theta)));
costxt.setText(String.format("%.3f", Math.cos(theta)));
tantxt.setText(String.format("%.3f", Math.tan(theta)));
} catch (NumberFormatException e) {
degree.setText(""); // 發生例外時清除輸入區內容
}
}
public void loseCoins() {
int x = player1.getX();
int y = player1.getY();
double losePercentage = 0.1;
for (int i = 0;
i < (int) coins * losePercentage;
i++) { // makes the user lose 10 percent of the coin and draws them in a circle
// System.out.println(i);
int xPos = x + (int) (100 * Math.cos(Math.toRadians((360 / (coins * losePercentage)) * i)));
int yPos = y - (int) (100 * Math.sin(Math.toRadians((360 / (coins * losePercentage)) * i)));
coinList.add(new Coin(xPos, yPos, 3));
}
coins -= (int) (coins * losePercentage);
}
@Override
protected void paintComponent(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
final Dimension size = getSize();
int _size = Math.min(size.width, size.height);
_size = Math.min(_size, 600);
if (myImage != null && myShouldInvalidate) {
if (myImage.getWidth(null) != _size) {
myImage = null;
}
}
myShouldInvalidate = false;
if (myImage == null) {
myImage =
createImage(
new ColorWheelImageProducer(
_size - BORDER_SIZE * 2, _size - BORDER_SIZE * 2, myBrightness));
myWheel =
new Rectangle(
BORDER_SIZE, BORDER_SIZE, _size - BORDER_SIZE * 2, _size - BORDER_SIZE * 2);
}
g.setColor(UIManager.getColor("Panel.background"));
g.fillRect(0, 0, getWidth(), getHeight());
g2d.setComposite(
AlphaComposite.getInstance(AlphaComposite.SRC_OVER, ((float) myOpacity) / 255f));
g.drawImage(myImage, myWheel.x, myWheel.y, null);
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC, 1.0f));
int mx = myWheel.x + myWheel.width / 2;
int my = myWheel.y + myWheel.height / 2;
//noinspection UseJBColor
g.setColor(Color.WHITE);
int arcw = (int) (myWheel.width * mySaturation / 2);
int arch = (int) (myWheel.height * mySaturation / 2);
double th = myHue * 2 * Math.PI;
final int x = (int) (mx + arcw * Math.cos(th));
final int y = (int) (my - arch * Math.sin(th));
g.fillRect(x - 2, y - 2, 4, 4);
//noinspection UseJBColor
g.setColor(Color.BLACK);
g.drawRect(x - 2, y - 2, 4, 4);
}
public void flecha(Graphics papel, int x1, int y1, int x2, int y2) {
double ang = 0.0, angSep = 0.0;
double tx = 0, ty = 0;
int dist = 0;
Point punto1 = null, punto2 = null;
punto2 = new Point(x1, y1);
punto1 = new Point(x2, y2);
dist = 15;
ty = -(punto1.y - punto2.y) * 1.0;
tx = (punto1.x - punto2.x) * 1.0;
ang = Math.atan(ty / tx);
if (tx < 0) ang += Math.PI;
Point p1 = new Point(), p2 = new Point(), punto = punto2;
angSep = 25.0;
p1.x = (int) (punto.x + dist * Math.cos(ang - Math.toRadians(angSep)));
p1.y = (int) (punto.y - dist * Math.sin(ang - Math.toRadians(angSep)));
p2.x = (int) (punto.x + dist * Math.cos(ang + Math.toRadians(angSep)));
p2.y = (int) (punto.y - dist * Math.sin(ang + Math.toRadians(angSep)));
Graphics2D g2D = (Graphics2D) papel;
papel.setColor(Color.black);
g2D.setStroke(new BasicStroke(1.2f));
papel.drawLine(punto1.x, punto1.y, punto.x, punto.y);
int x[] = {p1.x, punto.x, p2.x};
int y[] = {p1.y, punto.y, p2.y};
Polygon myTri = new Polygon(x, y, 3);
papel.setColor(Color.BLACK);
papel.drawPolygon(myTri);
papel.fillPolygon(myTri);
}
protected void recalcOutFreq() {
if (inRate == 0f) return;
double omegaIn, omegaOut, warp;
ParamField ggOutFreq;
omegaIn = pr.para[PR_INFREQ].val / inRate * Constants.PI2;
warp = Math.max(-0.98, Math.min(0.98, pr.para[PR_WARP].val / 100)); // DAFx2000 'b'
omegaOut = omegaIn + 2 * Math.atan2(warp * Math.sin(omegaIn), 1.0 - warp * Math.cos(omegaIn));
ggOutFreq = (ParamField) gui.getItemObj(GG_OUTFREQ);
if (ggOutFreq != null) {
ggOutFreq.setParam(new Param(omegaOut / Constants.PI2 * inRate, Param.ABS_HZ));
}
}
/** Recalculates the (x,y) point used to indicate the selected color. */
private void regeneratePoint() {
int size =
Math.min(
MAX_SIZE,
Math.min(
getWidth() - imagePadding.left - imagePadding.right,
getHeight() - imagePadding.top - imagePadding.bottom));
if (mode == ColorPicker.HUE || mode == ColorPicker.SAT || mode == ColorPicker.BRI) {
if (mode == ColorPicker.HUE) {
point = new Point((int) (sat * size), (int) (bri * size));
} else if (mode == ColorPicker.SAT) {
double theta = hue * 2 * Math.PI - Math.PI / 2;
if (theta < 0) theta += 2 * Math.PI;
double r = bri * size / 2;
point =
new Point(
(int) (r * Math.cos(theta) + .5 + size / 2.0),
(int) (r * Math.sin(theta) + .5 + size / 2.0));
} else if (mode == ColorPicker.BRI) {
double theta = hue * 2 * Math.PI - Math.PI / 2;
if (theta < 0) theta += 2 * Math.PI;
double r = sat * size / 2;
point =
new Point(
(int) (r * Math.cos(theta) + .5 + size / 2.0),
(int) (r * Math.sin(theta) + .5 + size / 2.0));
}
} else if (mode == ColorPicker.RED) {
point = new Point((int) (green * size / 255f + .49f), (int) (blue * size / 255f + .49f));
} else if (mode == ColorPicker.GREEN) {
point = new Point((int) (red * size / 255f + .49f), (int) (blue * size / 255f + .49f));
} else if (mode == ColorPicker.BLUE) {
point = new Point((int) (red * size / 255f + .49f), (int) (green * size / 255f + .49f));
}
}
/**
* Draws an open regular polygon with a specified number of sides.<br>
* The center of this polygon is specified by centerX,centerY and its size is specified by radius
* <br>
* (As in the radius of the circle the regular polygon would fit inside). <br>
* Precondition: sides >= 3 <br>
* Example: Expo.drawRegularPolygon(g,300,200,100,8); Draws an open regular octagon with a radius
* of 100 pixels whose center is located at the coordinate (300,200).
*/
public static void drawRegularPolygon(
Graphics g, int centerX, int centerY, int radius, int sides) {
int xCoord[] = new int[sides];
int yCoord[] = new int[sides];
double rotate;
if (sides % 2 == 1) rotate = halfPI;
else rotate = halfPI + Math.PI / sides;
for (int k = 0; k < sides; k++) {
xCoord[k] = (int) Math.round(Math.cos(twoPI * k / sides - rotate) * radius) + centerX;
yCoord[k] = (int) Math.round(Math.sin(twoPI * k / sides - rotate) * radius) + centerY;
}
if (sides == 3) yCoord[1] = yCoord[2];
g.drawPolygon(xCoord, yCoord, sides);
}
private Path2D.Double makeStar(int r1, int r2, int vc) {
int or = Math.max(r1, r2);
int ir = Math.min(r1, r2);
double agl = 0d;
double add = 2 * Math.PI / (vc * 2);
Path2D.Double p = new Path2D.Double();
p.moveTo(or * 1, or * 0);
for (int i = 0; i < vc * 2 - 1; i++) {
agl += add;
int r = i % 2 == 0 ? ir : or;
p.lineTo(r * Math.cos(agl), r * Math.sin(agl));
}
p.closePath();
AffineTransform at = AffineTransform.getRotateInstance(-Math.PI / 2, or, 0);
return new Path2D.Double(p, at);
}
/** Sets the location on the given dialog for the given index. */
private void setLocation(JDialog dialog, int index) {
Rectangle bounds = dialog.getBounds();
JFrame frame = findOwner();
Dimension dim;
if (frame == null) {
dim = Toolkit.getDefaultToolkit().getScreenSize();
} else {
dim = frame.getSize();
}
int x = (int) (150 * Math.cos(index * 15 * (Math.PI / 180)));
int y = (int) (150 * Math.sin(index * 15 * (Math.PI / 180)));
x += (dim.width - bounds.width) / 2;
y += (dim.height - bounds.height) / 2;
dialog.setLocation(x, y);
}
protected void recalcWarpAmount() {
if (inRate == 0f) return;
double omegaIn, omegaOut, warp, d1;
ParamField ggWarp;
omegaIn = pr.para[PR_INFREQ].val / inRate * Constants.PI2;
omegaOut = pr.para[PR_OUTFREQ].val / inRate * Constants.PI2;
d1 = Math.tan((omegaOut - omegaIn) / 2);
warp =
Math.max(
-0.98,
Math.min(0.98, d1 / (Math.sin(omegaIn) + Math.cos(omegaIn) * d1))); // DAFx2000 'b'
ggWarp = (ParamField) gui.getItemObj(GG_WARP);
if (ggWarp != null) {
ggWarp.setParam(new Param(warp * 100, Param.FACTOR));
}
}
private AnnotatedChartModel createCosineModel() {
DefaultChartModel model = new DefaultChartModel("Cosine");
int numIntervals = 36;
for (int i = 0; i <= numIntervals; i++) {
double x = (360.0 * i) / numIntervals;
double y = Math.cos(x * 2 * Math.PI / 360.0);
ChartPoint p = new ChartPoint(x, y);
model.addPoint(p);
}
ChartLabel label = new ChartLabel(new RealPosition(75.0), new RealPosition(8.0));
// As before we could simply use a basic string, but we are demonstrating the rich text mark-up
// possibility
label.setLabel(
"<html><p style='text-align:center'>A <span style='color:black'><b><u>Cosine</u></b></span><br>Wave</p></html>");
label.setColor(Color.gray);
model.addAnnotation(label);
ChartArrow arrow = new ChartArrow(new Point(75, 8), new Point(100, 20));
arrow.setFromPixelOffset(new Point(0, -10));
model.addAnnotation(arrow);
return model;
}
private Tile[] rotate(int angle) {
Tile[] newTiles = new Tile[4 * 4];
int offsetX = 3, offsetY = 3;
if (angle == 90) {
offsetY = 0;
} else if (angle == 270) {
offsetX = 0;
}
double rad = Math.toRadians(angle);
int cos = (int) Math.cos(rad);
int sin = (int) Math.sin(rad);
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
int newX = (x * cos) - (y * sin) + offsetX;
int newY = (x * sin) + (y * cos) + offsetY;
newTiles[(newX) + (newY) * 4] = tileAt(x, y);
}
}
return newTiles;
}
/*
* Defines a simple transformation matrix
* Outputs the transformation matrix
*/
public static double[][] DefineElementaryTransform(
double[][] inputMatrix, TRANSFORM_CODE transformCode, double transformValue) {
double[][] transMatrix = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}};
double[][] retMatrix = new double[4][4];
double radianVal = Math.PI * transformValue / 180;
switch (transformCode) {
case X_TRANS:
transMatrix[3][0] = transformValue;
break;
case Y_TRANS:
transMatrix[3][1] = transformValue;
break;
case Z_TRANS:
transMatrix[3][2] = transformValue;
break;
case Y_ROT:
transMatrix[0][0] = Math.cos(radianVal);
transMatrix[0][2] = -Math.sin(radianVal);
transMatrix[2][0] = Math.sin(radianVal);
transMatrix[2][2] = Math.cos(radianVal);
break;
case X_ROT:
transMatrix[1][1] = Math.cos(radianVal);
transMatrix[1][2] = Math.sin(radianVal);
transMatrix[2][1] = -Math.sin(radianVal);
transMatrix[2][2] = Math.cos(radianVal);
break;
case Z_ROT:
transMatrix[0][0] = Math.cos(radianVal);
transMatrix[0][1] = Math.sin(radianVal);
transMatrix[1][0] = -Math.sin(radianVal);
transMatrix[1][1] = Math.cos(radianVal);
break;
case PERSPECTIVE:
assert (transformValue != 0);
transMatrix[2][3] = -1 / transformValue;
break;
default:
System.out.println("Error: invalid code passed into function DefineElementaryTransform");
break;
}
retMatrix = MultiplyTransforms(inputMatrix, transMatrix);
return retMatrix;
}
public static void main(String[] args) {
JFrame frame = new JFrame();
Molecule molecule = new Molecule("H");
SiteType[] type = new SiteType[Colors.COLORARRAY.length];
for (int i = 0; i < type.length; i++) {
type[i] = new SiteType(molecule, "Type " + i);
type[i].setRadius(1 + 0.5 * (i % 3));
type[i].setColor(Colors.COLORARRAY[i]);
molecule.addType(type[i]);
}
Site[] site = new Site[3 * type.length];
for (int i = 0; i < site.length; i++) {
site[i] = new Site(molecule, type[i % type.length]);
site[i].setX(30 * Math.cos(2 * Math.PI * i / site.length));
site[i].setY(30 * Math.sin(2 * Math.PI * i / site.length));
site[i].setZ(6);
site[i].setLocation(SystemGeometry.INSIDE);
molecule.addSite(site[i]);
}
Link[] link = new Link[site.length - 1];
for (int i = 0; i < link.length; i++) {
link[i] = new Link(site[i], site[i + 1]);
molecule.addLink(link[i]);
}
DrawPanel3D panel3d = new DrawPanel3D(molecule);
DrawPanel3DPanel panel = new DrawPanel3DPanel(panel3d);
Container c = frame.getContentPane();
c.add(panel);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setSize(600, 400);
frame.setVisible(true);
}
private void spawnCircles() {
if (circular) {
for (int i = 0; i < ballN; i++) {
double degree = Math.random() * 2 * Math.PI;
float x = ((Player) players.get(0)).getX() + distance * (float) Math.sin(degree * i);
float y = ((Player) players.get(0)).getY() + distance * (float) Math.cos(degree * i);
enemies.add(new EnemyTypes.Circle(x, y, invSpeed));
}
} else {
for (int i = 1; i < (ballN / 2); i++) {
float x = (i * 2 * width) / (ballN);
float y = 0;
enemies.add(new EnemyTypes.Circle(x, y, invSpeed));
}
for (int i = (ballN / 2) + 1; i < ballN; i++) {
float x = ((i - ballN / 2) * 2 * width) / ballN;
float y = height;
enemies.add(new EnemyTypes.Circle(x, y, invSpeed));
}
}
spawnIncrease = false;
}
/** Rotate theta degrees about the x axis */
void xrot(double theta) {
theta *= (pi / 180);
double ct = Math.cos(theta);
double st = Math.sin(theta);
double Nyx = (yx * ct + zx * st);
double Nyy = (yy * ct + zy * st);
double Nyz = (yz * ct + zz * st);
double Nyo = (yo * ct + zo * st);
double Nzx = (zx * ct - yx * st);
double Nzy = (zy * ct - yy * st);
double Nzz = (zz * ct - yz * st);
double Nzo = (zo * ct - yo * st);
yo = Nyo;
yx = Nyx;
yy = Nyy;
yz = Nyz;
zo = Nzo;
zx = Nzx;
zy = Nzy;
zz = Nzz;
}
/** Rotate theta degrees about the z axis */
void zrot(double theta) {
theta *= pi / 180;
double ct = Math.cos(theta);
double st = Math.sin(theta);
double Nyx = (yx * ct + xx * st);
double Nyy = (yy * ct + xy * st);
double Nyz = (yz * ct + xz * st);
double Nyo = (yo * ct + xo * st);
double Nxx = (xx * ct - yx * st);
double Nxy = (xy * ct - yy * st);
double Nxz = (xz * ct - yz * st);
double Nxo = (xo * ct - yo * st);
yo = Nyo;
yx = Nyx;
yy = Nyy;
yz = Nyz;
xo = Nxo;
xx = Nxx;
xy = Nxy;
xz = Nxz;
}
/** Rotate theta degrees around the y axis */
void yrot(double theta) {
theta *= (pi / 180);
double ct = Math.cos(theta);
double st = Math.sin(theta);
double Nxx = (xx * ct + zx * st);
double Nxy = (xy * ct + zy * st);
double Nxz = (xz * ct + zz * st);
double Nxo = (xo * ct + zo * st);
double Nzx = (zx * ct - xx * st);
double Nzy = (zy * ct - xy * st);
double Nzz = (zz * ct - xz * st);
double Nzo = (zo * ct - xo * st);
xo = Nxo;
xx = Nxx;
xy = Nxy;
xz = Nxz;
zo = Nzo;
zx = Nzx;
zy = Nzy;
zz = Nzz;
}
public void move() {
objtimer++;
// move
if (xmot.random && objtimer % (int) (35 * xmot.randomchg) == 0) {
xspeed = xmot.speed * random(-1, 1, 2);
}
if (ymot.random && objtimer % (int) (35 * ymot.randomchg) == 0) {
yspeed = ymot.speed * random(-1, 1, 2);
}
if (player != null) {
double playerdist =
Math.sqrt((player.x - x) * (player.x - x) + (player.y - y) * (player.y - y))
* 100.0
/ (pfWidth());
if (xmot.toplayer && playerdist > xmot.toplayermin && playerdist < xmot.toplayermax) {
xspeed = 0;
x += xmot.speed * (player.x > x ? 1 : -1);
} else if (xmot.frplayer
&& playerdist > xmot.frplayermin
&& playerdist < xmot.frplayermax) {
xspeed = 0;
x += xmot.speed * (player.x < x ? 1 : -1);
}
if (ymot.toplayer && playerdist > ymot.toplayermin && playerdist < ymot.toplayermax) {
yspeed = 0;
y += ymot.speed * (player.y > y ? 1 : -1);
} else if (ymot.frplayer
&& playerdist > ymot.frplayermin
&& playerdist < ymot.frplayermax) {
yspeed = 0;
y += ymot.speed * (player.y < y ? 1 : -1);
}
}
// react to background
int bounces = 0;
if (bouncesides.equals("any")) {
bounces |= 15;
} else if (bouncesides.equals("top")) {
bounces |= 1;
} else if (bouncesides.equals("bottom")) {
bounces |= 2;
} else if (bouncesides.equals("topbottom")) {
bounces |= 3;
} else if (bouncesides.equals("left")) {
bounces |= 4;
} else if (bouncesides.equals("right")) {
bounces |= 8;
} else if (bouncesides.equals("leftright")) {
bounces |= 12;
}
if ((bounces & 1) != 0 && y < 0) {
y = 0;
if (yspeed < 0) yspeed = -yspeed;
}
if ((bounces & 2) != 0 && y > pfHeight() - 16) {
y = pfHeight() - 16;
if (yspeed > 0) yspeed = -yspeed;
}
if ((bounces & 4) != 0 && x < 0) {
x = 0;
if (xspeed < 0) xspeed = -xspeed;
}
if ((bounces & 8) != 0 && x > pfWidth() - 16) {
x = pfWidth() - 16;
if (xspeed > 0) xspeed = -xspeed;
}
// shoot
if (shoot && shootfreq > 0.0 && objtimer % (int) (shootfreq * 35) == 0) {
if (shootdir.equals("left")) {
new AgentBullet(x, y, bullettype, sprite, diebgtype | blockbgtype, -shootspeed, 0);
} else if (shootdir.equals("right")) {
new AgentBullet(x, y, bullettype, sprite, diebgtype | blockbgtype, shootspeed, 0);
} else if (shootdir.equals("up")) {
new AgentBullet(x, y, bullettype, sprite, diebgtype | blockbgtype, 0, -shootspeed);
} else if (shootdir.equals("down")) {
new AgentBullet(x, y, bullettype, sprite, diebgtype | blockbgtype, 0, shootspeed);
} else if (shootdir.equals("player") && player != null) {
double angle = Math.atan2(player.x - x, player.y - y);
new AgentBullet(
x,
y,
bullettype,
sprite,
diebgtype | blockbgtype,
shootspeed * Math.sin(angle),
shootspeed * Math.cos(angle));
}
}
}
private int yCor(int len, double dir) {
return (int) (len * Math.cos(dir));
}
/**
* Draws the stars on the flag. Two integer arrays are used to store the x-coordinates and
* y-coordinates of a star (a total of 10 points for each of the 10 vertices). The outer radius is
* then calculated by multiplying the actual height by the star diameter ratio then dividing by 2.
* The inner radius is then calculated using trigonometric relationships between the first point
* (outer right most point) and the point directly to the left of it (the inner right most point),
* based on the assumption that the y-coordinates of these points are the same. The method then
* uses a series of for loops to draw the stars, drawing them row by row and 1 by 1 across each
* row. The outer most for loop increments each row while also determining the number of stars in
* each row and the initial x offset for the first star, both of which vary depending on the row
* number. The intermediate for loop increments each column while also determining the X and Y
* coordinate centers for each star. The inner most for loop generates the x and y coordinates for
* each of the 10 vertices for each star and stores them in their respective arrays to be used by
* the fillPolygon method to draw each star.
*
* @param g The graphics component on which to draw the stars
* @param initialWidthOffset The initial width offset towards the right from the left side of the
* frame
* @param initialHeightOffset The initial height offset towards the bottom from the top of the
* frame
* @param actualWidth The actual width of the window, not including the frame border
* @param actualHeight The actual height of the window, not including the frame border
*/
public void drawStars(
Graphics g,
int initialWidthOffset,
int initialHeightOffset,
int actualWidth,
int actualHeight) {
g.setColor(Color.WHITE);
int[] xPoints = new int[10];
int[] yPoints = new int[10];
// outer radius
double r1 = actualHeight * (STAR_DIAMETER / 2);
// inner radius
double r2 = r1 * Math.sin(Math.toRadians(18)) / Math.sin(Math.toRadians(54));
for (int row = 0; row < 9; row++) {
/* The number of stars per row initially begin at 6 for the first row and alternate between
* 5 and 6 for each successive row.
*/
int starsPerRow = (row % 2 == 0) ? 6 : 5;
/* The initial star x offset is initially 1 for the first row, but alternates between 2
* and 1 for each successive row.
*/
int initialStarXOffset = (row % 2 == 0) ? 1 : 2;
for (int col = 0; col < starsPerRow; col++) {
/* The x-coordinate center is calculated based on the initial width offset and the star x
* offset proportional to the actual height, in addition to the initial star x offset and the
* column number. The x-coordinate center is incremented by the 2 times the star x offset in
* proportion to the actual height for each iteration of the intermediate for loop. The
* y-coordinate center is calculated based on the initial height offset and the star y offset
* proportional to the actual height, in addition to the row number. The y-coordinate center is
* incremented by the star y offset in proportion to the actual height for each iteration of the
* outer most for loop.
*/
int starCenterX =
(initialWidthOffset)
+ (int) ((actualHeight * STAR_X_OFFSET) * (initialStarXOffset + 2 * col));
int starCenterY =
(initialHeightOffset) + (int) ((actualHeight * STAR_Y_OFFSET) * (1 + row));
for (int i = 0; i < 10; i++) {
/* Assigns different x and y coordinates for each of the 10 points on a star depending on
* whether the point is an even/outer point (i % 2) == 0, or an odd/inner point. Points are
* calculated based on the center x and y coordinates and with the trigonometric sin and cos
* functions. The angle measure is incremented by 36 degrees for each iteration of the for loop, for
* use in the cos and sin functions.
*/
xPoints[i] =
(i % 2) == 0
? starCenterX + (int) (r1 * Math.cos(Math.toRadians(18 + 36 * i)))
: starCenterX + (int) (r2 * Math.cos(Math.toRadians(54 + 36 * (i - 1))));
yPoints[i] =
(i % 2) == 0
? starCenterY - (int) (r1 * Math.sin(Math.toRadians(18 + 36 * i)))
: starCenterY - (int) (r2 * Math.sin(Math.toRadians(54 + 36 * (i - 1))));
}
g.fillPolygon(xPoints, yPoints, 10);
}
}
}
/** Translation durchfuehren */
public void process() {
int i, j, k;
int ch, len;
float f1;
double d1, d2, d3, d4, d5;
long progOff, progLen, lo;
// io
AudioFile reInF = null;
AudioFile imInF = null;
AudioFile reOutF = null;
AudioFile imOutF = null;
AudioFileDescr reInStream = null;
AudioFileDescr imInStream = null;
AudioFileDescr reOutStream = null;
AudioFileDescr imOutStream = null;
FloatFile reFloatF[] = null;
FloatFile imFloatF[] = null;
File reTempFile[] = null;
File imTempFile[] = null;
int outChanNum;
float[][] reInBuf; // [ch][i]
float[][] imInBuf; // [ch][i]
float[][] reOutBuf = null; // [ch][i]
float[][] imOutBuf = null; // [ch][i]
float[] convBuf1, convBuf2;
boolean complex;
PathField ggOutput;
// Synthesize
Param ampRef = new Param(1.0, Param.ABS_AMP); // transform-Referenz
float gain; // gain abs amp
float dryGain, wetGain;
float inGain;
float maxAmp = 0.0f;
Param peakGain;
int inLength, inOff;
int pre;
int post;
int length;
int framesRead, framesWritten, outLength;
boolean polarIn, polarOut;
// phase unwrapping
double[] phi;
int[] wrap;
double[] carry;
Param lenRef;
topLevel:
try {
complex = pr.bool[PR_HASIMINPUT] || pr.bool[PR_HASIMOUTPUT];
polarIn = pr.intg[PR_OPERATOR] == OP_POLAR2RECT;
polarOut = pr.intg[PR_OPERATOR] == OP_RECT2POLAR;
if ((polarIn || polarOut) && !complex) throw new IOException(ERR_NOTCOMPLEX);
// ---- open input ----
reInF = AudioFile.openAsRead(new File(pr.text[PR_REINPUTFILE]));
reInStream = reInF.getDescr();
inLength = (int) reInStream.length;
reInBuf = new float[reInStream.channels][8192];
imInBuf = new float[reInStream.channels][8192];
if (pr.bool[PR_HASIMINPUT]) {
imInF = AudioFile.openAsRead(new File(pr.text[PR_IMINPUTFILE]));
imInStream = imInF.getDescr();
if (imInStream.channels != reInStream.channels) throw new IOException(ERR_COMPLEX);
inLength = (int) Math.min(inLength, imInStream.length);
}
lenRef = new Param(AudioFileDescr.samplesToMillis(reInStream, inLength), Param.ABS_MS);
d1 =
AudioFileDescr.millisToSamples(
reInStream, (Param.transform(pr.para[PR_OFFSET], Param.ABS_MS, lenRef, null).value));
j = (int) (d1 >= 0.0 ? (d1 + 0.5) : (d1 - 0.5)); // correct rounding for negative values!
length =
(int)
(AudioFileDescr.millisToSamples(
reInStream,
(Param.transform(pr.para[PR_LENGTH], Param.ABS_MS, lenRef, null)).value)
+ 0.5);
// System.err.println( "offset = "+j );
if (j >= 0) {
inOff = Math.min(j, inLength);
if (!pr.bool[PR_REVERSE]) {
reInF.seekFrame(inOff);
if (pr.bool[PR_HASIMINPUT]) {
imInF.seekFrame(inOff);
}
}
inLength -= inOff;
pre = 0;
} else {
inOff = 0;
pre = Math.min(-j, length);
}
inLength = Math.min(inLength, length - pre);
post = length - pre - inLength;
if (pr.bool[PR_REVERSE]) {
i = pre;
pre = post;
post = i;
inOff += inLength;
}
// .... check running ....
if (!threadRunning) break topLevel;
// for( op = 0; op < 2; op++ ) {
// System.out.println( op +": pre "+pre[op]+" / len "+inLength[op]+" / post "+post[op] );
// }
// System.out.println( "tot "+length[0]);
outLength = length;
outChanNum = reInStream.channels;
// ---- open output ----
ggOutput = (PathField) gui.getItemObj(GG_REOUTPUTFILE);
if (ggOutput == null) throw new IOException(ERR_MISSINGPROP);
reOutStream = new AudioFileDescr(reInStream);
ggOutput.fillStream(reOutStream);
reOutStream.channels = outChanNum;
// well, more sophisticated code would
// move and truncate the markers...
if ((pre == 0) /* && (post == 0) */) {
reInF.readMarkers();
reOutStream.setProperty(
AudioFileDescr.KEY_MARKERS, reInStream.getProperty(AudioFileDescr.KEY_MARKERS));
}
reOutF = AudioFile.openAsWrite(reOutStream);
reOutBuf = new float[outChanNum][8192];
imOutBuf = new float[outChanNum][8192];
if (pr.bool[PR_HASIMOUTPUT]) {
imOutStream = new AudioFileDescr(reInStream);
ggOutput.fillStream(imOutStream);
imOutStream.channels = outChanNum;
imOutStream.file = new File(pr.text[PR_IMOUTPUTFILE]);
imOutF = AudioFile.openAsWrite(imOutStream);
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Further inits ----
phi = new double[outChanNum];
wrap = new int[outChanNum];
carry = new double[outChanNum];
for (ch = 0; ch < outChanNum; ch++) {
phi[ch] = 0.0;
wrap[ch] = 0;
carry[ch] = Double.NEGATIVE_INFINITY;
}
progOff = 0; // read, transform, write
progLen = (long) outLength * 3;
wetGain = (float) (Param.transform(pr.para[PR_WETMIX], Param.ABS_AMP, ampRef, null)).value;
dryGain = (float) (Param.transform(pr.para[PR_DRYMIX], Param.ABS_AMP, ampRef, null)).value;
if (pr.bool[PR_DRYINVERT]) {
dryGain = -dryGain;
}
inGain = (float) (Param.transform(pr.para[PR_INPUTGAIN], Param.ABS_AMP, ampRef, null)).value;
if (pr.bool[PR_INVERT]) {
inGain = -inGain;
}
// normalization requires temp files
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
reTempFile = new File[outChanNum];
reFloatF = new FloatFile[outChanNum];
for (ch = 0;
ch < outChanNum;
ch++) { // first zero them because an exception might be thrown
reTempFile[ch] = null;
reFloatF[ch] = null;
}
for (ch = 0; ch < outChanNum; ch++) {
reTempFile[ch] = IOUtil.createTempFile();
reFloatF[ch] = new FloatFile(reTempFile[ch], GenericFile.MODE_OUTPUT);
}
if (pr.bool[PR_HASIMOUTPUT]) {
imTempFile = new File[outChanNum];
imFloatF = new FloatFile[outChanNum];
for (ch = 0;
ch < outChanNum;
ch++) { // first zero them because an exception might be thrown
imTempFile[ch] = null;
imFloatF[ch] = null;
}
for (ch = 0; ch < outChanNum; ch++) {
imTempFile[ch] = IOUtil.createTempFile();
imFloatF[ch] = new FloatFile(imTempFile[ch], GenericFile.MODE_OUTPUT);
}
}
progLen += outLength;
} else {
gain = (float) (Param.transform(pr.para[PR_GAIN], Param.ABS_AMP, ampRef, null)).value;
wetGain *= gain;
dryGain *= gain;
}
// .... check running ....
if (!threadRunning) break topLevel;
// ----==================== the real stuff ====================----
framesRead = 0;
framesWritten = 0;
while (threadRunning && (framesWritten < outLength)) {
// ---- choose chunk len ----
len = Math.min(8192, outLength - framesWritten);
if (pre > 0) {
len = Math.min(len, pre);
} else if (inLength > 0) {
len = Math.min(len, inLength);
} else {
len = Math.min(len, post);
}
// ---- read input chunks ----
if (pre > 0) {
Util.clear(reInBuf);
if (complex) {
Util.clear(imInBuf);
}
pre -= len;
} else if (inLength > 0) {
if (pr.bool[PR_REVERSE]) { // ---- read reversed ----
reInF.seekFrame(inOff - framesRead - len);
reInF.readFrames(reInBuf, 0, len);
for (ch = 0; ch < reInStream.channels; ch++) {
convBuf1 = reInBuf[ch];
for (i = 0, j = len - 1; i < j; i++, j--) {
f1 = convBuf1[j];
convBuf1[j] = convBuf1[i];
convBuf1[i] = f1;
}
}
if (pr.bool[PR_HASIMINPUT]) {
imInF.seekFrame(inOff - framesRead - len);
imInF.readFrames(imInBuf, 0, len);
for (ch = 0; ch < imInStream.channels; ch++) {
convBuf1 = imInBuf[ch];
for (i = 0, j = len - 1; i < j; i++, j--) {
f1 = convBuf1[j];
convBuf1[j] = convBuf1[i];
convBuf1[i] = f1;
}
}
} else if (complex) {
Util.clear(imInBuf);
}
} else { // ---- read normal ----
reInF.readFrames(reInBuf, 0, len);
if (pr.bool[PR_HASIMINPUT]) {
imInF.readFrames(imInBuf, 0, len);
} else if (complex) {
Util.clear(imInBuf);
}
}
inLength -= len;
framesRead += len;
} else {
Util.clear(reInBuf);
if (complex) {
Util.clear(imInBuf);
}
post -= len;
}
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- save dry signal ----
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = reOutBuf[ch];
for (i = 0; i < len; i++) {
convBuf2[i] = convBuf1[i] * dryGain;
}
if (complex) {
convBuf1 = imInBuf[ch];
convBuf2 = imOutBuf[ch];
for (i = 0; i < len; i++) {
convBuf2[i] = convBuf1[i] * dryGain;
}
}
}
// ---- rectify + apply input gain ----
for (ch = 0; ch < reInStream.channels; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = imInBuf[ch];
// ---- rectify ----
if (pr.bool[PR_RECTIFY]) {
if (complex) {
if (polarIn) {
for (i = 0; i < len; i++) {
convBuf2[i] = 0.0f;
}
} else {
for (i = 0; i < len; i++) {
d1 = convBuf1[i];
d2 = convBuf2[i];
convBuf1[i] = (float) Math.sqrt(d1 * d1 + d2 * d2);
convBuf2[i] = 0.0f;
}
}
} else {
for (i = 0; i < len; i++) {
convBuf1[i] = Math.abs(convBuf1[i]);
}
}
}
// ---- apply input gain ----
Util.mult(convBuf1, 0, len, inGain);
if (complex & !polarIn) {
Util.mult(convBuf2, 0, len, inGain);
}
}
// ---- heart of the dragon ----
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reInBuf[ch];
convBuf2 = imInBuf[ch];
switch (pr.intg[PR_OPERATOR]) {
case OP_NONE: // ================ None ================
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * convBuf1[i];
}
if (complex) {
for (i = 0; i < len; i++) {
imOutBuf[ch][i] += wetGain * convBuf2[i];
}
}
break;
case OP_SIN: // ================ Cosinus ================
if (complex) {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
imOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf2[i] * Math.PI);
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.sin(convBuf1[i] * Math.PI);
}
}
break;
case OP_SQR: // ================ Square ================
if (complex) {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] +=
wetGain * (convBuf1[i] * convBuf1[i] - convBuf2[i] * convBuf2[i]);
imOutBuf[ch][i] -= wetGain * (convBuf1[i] * convBuf2[i] * 2);
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (convBuf1[i] * convBuf1[i]);
}
}
break;
case OP_SQRT: // ================ Square root ================
if (complex) {
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
for (i = 0; i < len; i++) {
d1 =
wetGain
* Math.pow(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i], 0.25);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
d2 += d4;
d3 = d2;
d2 /= 2;
reOutBuf[ch][i] += (float) (d1 * Math.cos(d2));
imOutBuf[ch][i] += (float) (d1 * Math.sin(d2));
}
phi[ch] = d3;
wrap[ch] = k;
} else {
for (i = 0; i < len; i++) {
f1 = convBuf1[i];
if (f1 > 0) {
reOutBuf[ch][i] += wetGain * (float) Math.sqrt(f1);
} // else undefiniert
}
}
break;
case OP_RECT2POLARW: // ================ Rect->Polar (wrapped) ================
for (i = 0; i < len; i++) {
d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
reOutBuf[ch][i] += (float) d1;
imOutBuf[ch][i] += (float) d2;
}
break;
case OP_RECT2POLAR: // ================ Rect->Polar ================
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
for (i = 0; i < len; i++) {
d1 = wetGain * Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
d2 += d4;
reOutBuf[ch][i] += (float) d1;
imOutBuf[ch][i] += (float) d2;
d3 = d2;
}
phi[ch] = d3;
wrap[ch] = k;
break;
case OP_POLAR2RECT: // ================ Polar->Rect ================
for (i = 0; i < len; i++) {
f1 = wetGain * convBuf1[i];
reOutBuf[ch][i] += f1 * (float) Math.cos(convBuf2[i]);
imOutBuf[ch][i] += f1 * (float) Math.sin(convBuf2[i]);
}
break;
case OP_LOG: // ================ Log ================
if (complex) {
d3 = phi[ch];
k = wrap[ch];
d4 = k * Constants.PI2;
d5 = carry[ch];
for (i = 0; i < len; i++) {
d1 = Math.sqrt(convBuf1[i] * convBuf1[i] + convBuf2[i] * convBuf2[i]);
d2 = Math.atan2(convBuf2[i], convBuf1[i]);
if (d2 - d3 > Math.PI) {
k--;
d4 = k * Constants.PI2;
} else if (d3 - d2 > Math.PI) {
k++;
d4 = k * Constants.PI2;
}
if (d1 > 0.0) {
d5 = Math.log(d1);
}
d2 += d4;
reOutBuf[ch][i] += (float) d5;
imOutBuf[ch][i] += (float) d2;
d3 = d2;
}
phi[ch] = d3;
wrap[ch] = k;
carry[ch] = d5;
} else {
for (i = 0; i < len; i++) {
f1 = convBuf1[i];
if (f1 > 0) {
reOutBuf[ch][i] += wetGain * (float) Math.log(f1);
} // else undefiniert
}
}
break;
case OP_EXP: // ================ Exp ================
if (complex) {
for (i = 0; i < len; i++) {
d1 = wetGain * Math.exp(convBuf1[i]);
reOutBuf[ch][i] += (float) (d1 * Math.cos(convBuf2[i]));
imOutBuf[ch][i] += (float) (d1 * Math.sin(convBuf2[i]));
}
} else {
for (i = 0; i < len; i++) {
reOutBuf[ch][i] += wetGain * (float) Math.exp(convBuf1[i]);
}
}
break;
case OP_NOT: // ================ NOT ================
for (i = 0; i < len; i++) {
lo = ~((long) (convBuf1[i] * 2147483647.0));
reOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
}
if (complex) {
for (i = 0; i < len; i++) {
lo = ~((long) (convBuf2[i] * 2147483647.0));
imOutBuf[ch][i] += wetGain * (float) ((lo & 0xFFFFFFFFL) / 2147483647.0);
}
}
break;
}
} // for outChan
progOff += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
// .... check running ....
if (!threadRunning) break topLevel;
// ---- write output chunk ----
if (reFloatF != null) {
for (ch = 0; ch < outChanNum; ch++) {
reFloatF[ch].writeFloats(reOutBuf[ch], 0, len);
if (pr.bool[PR_HASIMOUTPUT]) {
imFloatF[ch].writeFloats(imOutBuf[ch], 0, len);
}
}
} else {
reOutF.writeFrames(reOutBuf, 0, len);
if (pr.bool[PR_HASIMOUTPUT]) {
imOutF.writeFrames(imOutBuf, 0, len);
}
}
// check max amp
for (ch = 0; ch < outChanNum; ch++) {
convBuf1 = reOutBuf[ch];
for (i = 0; i < len; i++) {
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
if (pr.bool[PR_HASIMOUTPUT]) {
convBuf1 = imOutBuf[ch];
for (i = 0; i < len; i++) {
f1 = Math.abs(convBuf1[i]);
if (f1 > maxAmp) {
maxAmp = f1;
}
}
}
}
progOff += len;
framesWritten += len;
// .... progress ....
setProgression((float) progOff / (float) progLen);
} // while not framesWritten
// ----==================== normalize output ====================----
if (pr.intg[PR_GAINTYPE] == GAIN_UNITY) {
peakGain = new Param(maxAmp, Param.ABS_AMP);
gain =
(float)
(Param.transform(
pr.para[PR_GAIN],
Param.ABS_AMP,
new Param(1.0 / peakGain.value, peakGain.unit),
null))
.value;
f1 = pr.bool[PR_HASIMOUTPUT] ? ((1.0f + getProgression()) / 2) : 1.0f;
normalizeAudioFile(reFloatF, reOutF, reOutBuf, gain, f1);
if (pr.bool[PR_HASIMOUTPUT]) {
normalizeAudioFile(imFloatF, imOutF, imOutBuf, gain, 1.0f);
}
maxAmp *= gain;
for (ch = 0; ch < outChanNum; ch++) {
reFloatF[ch].cleanUp();
reFloatF[ch] = null;
reTempFile[ch].delete();
reTempFile[ch] = null;
if (pr.bool[PR_HASIMOUTPUT]) {
imFloatF[ch].cleanUp();
imFloatF[ch] = null;
imTempFile[ch].delete();
imTempFile[ch] = null;
}
}
}
// .... check running ....
if (!threadRunning) break topLevel;
// ---- Finish ----
reOutF.close();
reOutF = null;
reOutStream = null;
if (imOutF != null) {
imOutF.close();
imOutF = null;
imOutStream = null;
}
reInF.close();
reInF = null;
reInStream = null;
if (pr.bool[PR_HASIMINPUT]) {
imInF.close();
imInF = null;
imInStream = null;
}
reOutBuf = null;
imOutBuf = null;
reInBuf = null;
imInBuf = null;
// inform about clipping/ low level
handleClipping(maxAmp);
} catch (IOException e1) {
setError(e1);
} catch (OutOfMemoryError e2) {
reOutBuf = null;
imOutBuf = null;
reInBuf = null;
imInBuf = null;
convBuf1 = null;
convBuf2 = null;
System.gc();
setError(new Exception(ERR_MEMORY));
}
// ---- cleanup (topLevel) ----
convBuf1 = null;
convBuf2 = null;
if (reInF != null) {
reInF.cleanUp();
reInF = null;
}
if (imInF != null) {
imInF.cleanUp();
imInF = null;
}
if (reOutF != null) {
reOutF.cleanUp();
reOutF = null;
}
if (imOutF != null) {
imOutF.cleanUp();
imOutF = null;
}
if (reFloatF != null) {
for (ch = 0; ch < reFloatF.length; ch++) {
if (reFloatF[ch] != null) {
reFloatF[ch].cleanUp();
reFloatF[ch] = null;
}
if (reTempFile[ch] != null) {
reTempFile[ch].delete();
reTempFile[ch] = null;
}
}
}
if (imFloatF != null) {
for (ch = 0; ch < imFloatF.length; ch++) {
if (imFloatF[ch] != null) {
imFloatF[ch].cleanUp();
imFloatF[ch] = null;
}
if (imTempFile[ch] != null) {
imTempFile[ch].delete();
imTempFile[ch] = null;
}
}
}
} // process()
