public static float gaussian(float x, float mean, float sd) {
float mu = mean;
float sigma = sd;
float k1 = (float) ((float) 1 / (sigma * (Math.sqrt(2 * Math.PI))));
float k2 = -1 / (2 * (sigma * sigma));
return (float) (k1 * Math.exp((x - mu) * (x - mu) * k2));
}
double rodbard(double x) {
// y = c*((a-x/(x-d))^(1/b)
// a=3.9, b=.88, c=712, d=44
double ex;
if (x == 0.0) ex = 5.0;
else ex = Math.exp(Math.log(x / 700.0) * 0.88);
double y = 3.9 - 44.0;
y = y / (1.0 + ex);
return y + 44.0;
}
public void setXY(double x, double y) {
// not validated
// x and y between -1 and 1
double sigmoidSteepness, sigmoidZero, baseLength;
double sensitivity =
1.1; // evaluated with set to 1.1: a sensitivity of 1 means the complete space of the button
// is used. 2 means only the middle part is used, making it more sensitive and more
// easy to get to extreme arousal (from a CHI perspective).
if (!down) {
p = x * sensitivity;
d = y * sensitivity;
baseLength = Math.max(Math.abs(p), Math.abs(d)); // MAX (P, D) base
// baseLength=Math.sqrt(Math.pow(p,2)+Math.pow(d,2))/Math.sqrt(2.0); //euclid P,D base
// now do the mapping to arousal.
// Arousal is controlled simple by using a Sigmoid function based on length of PD vector
sigmoidSteepness = 11;
sigmoidZero = 8;
a = 2 / (1 + Math.exp(-(sigmoidSteepness * baseLength - sigmoidZero))) - 1;
a_base = a;
// Arousal is controlled simply by using a quadratic function that has 0,0,0 as middle point,
// then drops to -1, then to 1 based MIN (P,D) length (mimics better original linear)
// sigmoidSteepness=6;
// sigmoidZero=0.35;
// a=sigmoidSteepness*Math.pow(Math.max(Math.abs(p),Math.abs(d))-sigmoidZero, 2)-1;
p = (p > 1 ? 1 : (p < -1 ? -1 : p));
d = (d > 1 ? 1 : (d < -1 ? -1 : d));
a = (a > 1 ? 1 : (a < -1 ? -1 : a));
} else {
double tmp_p, tmp_d;
tmp_p = x * sensitivity;
tmp_d = y * sensitivity;
baseLength = Math.max(Math.abs(tmp_p), Math.abs(tmp_d)); // MAX (P, D) base
// baseLength=Math.sqrt(Math.pow(p,2)+Math.pow(d,2))/Math.sqrt(2.0); //euclid P,D base
// now do the mapping to arousal.
// Arousal is controlled simple by using a Sigmoid function based on length of PD vector
sigmoidSteepness = 11;
sigmoidZero = 8;
// a=a_base-(d-tmp_d)+2/(1+Math.exp(-(sigmoidSteepness*baseLength-sigmoidZero)))-1;
a = tmp_d;
// Arousal is controlled simply by using a quadratic function that has 0,0,0 as middle point,
// then drops to -1, then to 1 based MIN (P,D) length (mimics better original linear)
// sigmoidSteepness=6;
// sigmoidZero=0.35;
// a=sigmoidSteepness*Math.pow(Math.max(Math.abs(p),Math.abs(d))-sigmoidZero, 2)-1;
// p=(p>1?1:(p<-1?-1:p));
// d=(d>1?1:(d<-1?-1:d));
a = (a > 1 ? 1 : (a < -1 ? -1 : a));
}
}
public double density(int x, int y) {
double tmpx, tmpy, tmpxy, det, varx, vary;
varx = ksx * ksx;
vary = ksy * ksy;
det = varx * vary - ksxy * ksxy;
tmpx = (x - kmx) * (x - kmx);
tmpy = (y - kmy) * (y - kmy);
tmpxy = (x - kmx) * (y - kmy);
return weight
/ Math.sqrt(det)
/ 6.28319
* Math.exp(-(tmpx * vary + tmpy * varx - 2 * tmpxy * ksxy) / det / 2);
}
static {
g = new float[3][3];
sum = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
int x = i - 1;
int y = j - 1;
g[i][j] = (float) Math.exp(-(x * x + y * y) / (2.0 * 0.8));
sum += g[i][j];
}
}
sum1 = g[0][0] + g[0][1] + g[0][2] + g[1][0] + g[1][1] + g[1][2];
}
/**
* create a random surface
*
* @param obj
* @param x1:surface x begin
* @param x2:surface x end
* @param y1:surface y begin
* @param y2:surface y end
* @return: the surface mObject
*/
private mObject createRandomSurface(mObject obj, int x1, int x2, int y1, int y2) {
int i = 0, j = 0;
x1 /= 20;
x2 /= 20;
y1 /= 20;
y2 /= 20;
mPoint3[][] points = new mPoint3[x2 - x1 + 1][y2 - y1 + 1];
for (i = y1; i <= y2; i++) {
for (j = x1; j <= x2; j++) {
points[j - x1][i - y1] =
new mPoint3(j * 20, i * 20, (float) (Math.random() * 70 * Math.exp(0 - 0.3 * j)));
}
}
return new mSurface(points, x2 - x1 + 1, y2 - y1 + 1);
}
public CellularFilter() {
results = new Point[3];
for (int j = 0; j < results.length; j++) results[j] = new Point();
if (probabilities == null) {
probabilities = new byte[8192];
float factorial = 1;
float total = 0;
float mean = 2.5f;
for (int i = 0; i < 10; i++) {
if (i > 1) factorial *= i;
float probability = (float) Math.pow(mean, i) * (float) Math.exp(-mean) / factorial;
int start = (int) (total * 8192);
total += probability;
int end = (int) (total * 8192);
for (int j = start; j < end; j++) probabilities[j] = (byte) i;
}
}
}
public IntensityFeatureScaleSpacePyramidApp(Class<T> imageType, Class<D> derivType) {
super(1);
this.imageType = imageType;
addAlgorithm(
0,
"Hessian Det",
new WrapperHessianBlobIntensity<T, D>(HessianBlobIntensity.Type.DETERMINANT, derivType));
addAlgorithm(
0,
"Laplacian",
new WrapperHessianBlobIntensity<T, D>(HessianBlobIntensity.Type.TRACE, derivType));
addAlgorithm(
0,
"Harris",
new WrapperGradientCornerIntensity<T, D>(
FactoryIntensityPointAlg.harris(2, 0.4f, false, derivType)));
addAlgorithm(
0,
"Shi Tomasi",
new WrapperGradientCornerIntensity<T, D>(
FactoryIntensityPointAlg.shiTomasi(2, false, derivType)));
addAlgorithm(
0,
"FAST 12",
new WrapperFastCornerIntensity<T, D>(FactoryIntensityPointAlg.fast12(5, 11, imageType)));
addAlgorithm(0, "KitRos", new WrapperKitRosCornerIntensity<T, D>(derivType));
addAlgorithm(
0,
"Median",
new WrapperMedianCornerIntensity<T, D>(FactoryBlurFilter.median(imageType, 2), imageType));
setMainGUI(gui);
double scales[] = new double[25];
for (int i = 0; i < scales.length; i++) {
scales[i] = Math.exp(i * 0.15);
}
pyramid = new ScaleSpacePyramid<T>(imageType, scales);
anyDerivative =
GImageDerivativeOps.createDerivatives(imageType, FactoryImageGenerator.create(derivType));
}
private void doDrawing(Graphics g, double std, int sig, int val) {
double gaus;
Graphics2D g2d = (Graphics2D) g;
double Xawal = X_AXIS_FIRST_X_COORD;
double Yawal = Y_AXIS_SECOND_Y_COORD;
Point2D.Double point = new Point2D.Double(Xawal, Yawal);
double xLength = (X_AXIS_SECOND_X_COORD - X_AXIS_FIRST_X_COORD) / xCoordNumbers;
double yLength = (Y_AXIS_SECOND_Y_COORD - Y_AXIS_FIRST_Y_COORD) / yCoordNumbers;
if (val == 0) {
g2d.setColor(Color.blue);
} else if (val == 1) {
g2d.setColor(Color.red);
} else if (val == 2) {
g2d.setColor(Color.black);
}
double tempX = 0.0, tempY = 0.0;
double i = (double) nilaiAwal[val];
while (i <= nilaiAkhir[val]) {
gaus = Math.exp(-((Math.pow((i - sig) / std, 2))));
// System.out.println(gaus);
if (gaus > 1.0) {
gaus = 0.0;
}
Xawal = X_AXIS_FIRST_X_COORD + (i * xLength) - 3;
Yawal = Y_AXIS_SECOND_Y_COORD - ((gaus * 10) * yLength);
if (i == nilaiAwal[val]) {
tempX = X_AXIS_FIRST_X_COORD + (i * xLength) - 3;
;
tempY = Y_AXIS_SECOND_Y_COORD - ((gaus * 10) * yLength);
}
g2d.draw(new Line2D.Double(tempX, tempY, Xawal, Yawal));
tempX = X_AXIS_FIRST_X_COORD + (i * xLength) - 3;
tempY = Y_AXIS_SECOND_Y_COORD - ((gaus * 10) * yLength);
i = i + 0.1;
}
// for(int i=nilaiAwal;i<=xCoordNumbers;i++){
// }
}
/** 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()
public double evaluate_1(double x) {
return (2 * x / x * x + 1)
- 0.4 * Math.exp(0.4 * x) * Math.cos(Math.PI * x)
+ Math.PI * Math.exp(0.4 * x) * Math.sin(Math.PI * x);
}
public double evaluate(double x) {
return Math.log(x * x + 1) - Math.exp(0.4 * x) * Math.cos(Math.PI * x);
}
public static double exp10(double val) {
return Math.exp(val / LOG10SCALE);
}
/**
* Applies a gaussian blur filter to the given image. Apart from the filter radius, you can also
* specify an alpha factor which will be multiplied with the filter's result. Also, you can
* specify whether the blurred image should be rendered into a newly created BufferedImage
* instance or into the original image. If you request a new image instance, the result will be
* larger than the original one as a (2*filterradius) pixel wide padding will be applied.
*
* @param image the image to be blurred.
* @param filterRadius the radius of the gaussian filter to apply. The corresponding kernel will
* be sized 2 * filterRadius + 1;
* @param alphaFactor a factor which will be multiplied with the filtered image. You can use this
* parameter to weaken or strengthen the colors in the blurred image.
* @param useOriginalImageAsDestination Determines whether the blur result should be rendered into
* the original image or into a new image instance. If you choose to create a new image
* instance, the result will be larger than the original image to provide the required padding
* for the blur effect.
* @return An image instance containing a blurred version of the given image.
*/
public static BufferedImage applyGaussianBlur(
final BufferedImage image,
final int filterRadius,
final float alphaFactor,
final boolean useOriginalImageAsDestination) {
if (filterRadius < 1) {
throw new IllegalArgumentException(
"Illegal filter radius: expected to be >= 1, was " + filterRadius);
}
float[] kernel = new float[2 * filterRadius + 1];
final float sigma = filterRadius / 3f;
final float alpha = 2f * sigma * sigma;
final float rootAlphaPI = (float) Math.sqrt(alpha * Math.PI);
float sum = 0;
for (int i = -0; i < kernel.length; i++) {
final int d = -((i - filterRadius) * (i - filterRadius));
kernel[i] = (float) (Math.exp(d / alpha) / rootAlphaPI);
sum += kernel[i];
}
for (int i = 0; i < kernel.length; i++) {
kernel[i] /= sum;
kernel[i] *= alphaFactor;
}
final Kernel horizontalKernel = new Kernel(kernel.length, 1, kernel);
final Kernel verticalKernel = new Kernel(1, kernel.length, kernel);
synchronized (BlurUtils.class) {
final int blurredWidth =
useOriginalImageAsDestination ? image.getWidth() : image.getWidth() + 4 * filterRadius;
final int blurredHeight =
useOriginalImageAsDestination ? image.getHeight() : image.getHeight() + 4 * filterRadius;
final BufferedImage img0 = ensureBuffer0Capacity(blurredWidth, blurredHeight);
final Graphics2D graphics0 = img0.createGraphics();
graphics0.drawImage(
image,
null,
useOriginalImageAsDestination ? 0 : 2 * filterRadius,
useOriginalImageAsDestination ? 0 : 2 * filterRadius);
graphics0.dispose();
final BufferedImage img1 = ensureBuffer1Capacity(blurredWidth, blurredHeight);
final Graphics2D graphics1 = img1.createGraphics();
graphics1.drawImage(
img0, new ConvolveOp(horizontalKernel, ConvolveOp.EDGE_NO_OP, null), 0, 0);
graphics1.dispose();
BufferedImage destination =
useOriginalImageAsDestination
? image
: new BufferedImage(blurredWidth, blurredHeight, BufferedImage.TYPE_INT_ARGB);
final Graphics2D destGraphics = destination.createGraphics();
destGraphics.drawImage(
img1, new ConvolveOp(verticalKernel, ConvolveOp.EDGE_NO_OP, null), 0, 0);
destGraphics.dispose();
return destination;
}
}