vector data_get_intensive_norm(SimpleGraphData * data)
{
if (data->b_intensive_norm == 0)
{
vector intensive = data_get_intensive_cutted(data);
data->d_intensive_norm = normalizev(intensive, MASK_MIN, MASK_MAX);
data->b_intensive_norm == 1;
}
return data->d_intensive_norm;
}
vector data_get_pitch_norm(SimpleGraphData * data)
{
if (data->b_pitch_norm == 0)
{
vector pitch = data_get_pitch(data);
data->d_pitch_norm = normalizev(pitch, MASK_MIN, MASK_MAX);
data->b_pitch_norm = 1;
}
return data->d_pitch_norm;
}
vector data_cepstrum_norm(SimpleGraphData * data)
{
if (data->b_cepstrum_norm == 0)
{
vector spec = data_cepstrum(data);
data->d_cepstrum_norm = normalizev(spec, MASK_MIN, MASK_MAX);
data->b_cepstrum_norm = 1;
}
return data->d_cepstrum_norm;
}
vector getFileMask(WaveFile* waveFile, vector wave, int len, char marker = NULL)
{
vector mask;
ListChunk * listLablChunk = NULL;
ListChunk * listLtxtChunk = NULL;
qDebug() << "listCount " << waveFile->listCount << LOG_DATA;
for (int i=0; i<waveFile->listCount; i++)
{
ListChunk * listChunk = &(waveFile->listChunks[i]);
if (listChunk == NULL) continue;
qDebug() << "listChunk->lablCount " << listChunk->lablCount << LOG_DATA;
if (listChunk->lablChunks != NULL && listChunk->lablCount > 0)
{
listLablChunk = listChunk;
}
qDebug() << "listChunk->ltxtCount " << listChunk->ltxtCount << LOG_DATA;
if (listChunk->ltxtChunks != NULL && listChunk->ltxtCount > 0)
{
listLtxtChunk = listChunk;
}
}
bool tryFileData = (waveFile->cueChunk != NULL)
&& (littleEndianBytesToUInt16(waveFile->cueChunk->cuePointsCount) > 0)
&& (listLtxtChunk != NULL)
&& (listLtxtChunk->ltxtChunks != NULL)
&& (listLtxtChunk->ltxtCount > 0)
&& (listLablChunk != NULL)
&& (listLablChunk->lablChunks != NULL)
&& (listLablChunk->lablCount > 0);
if (tryFileData)
{
qDebug() << "tryFileData" << LOG_DATA;
vector mask_from_file = readMaskFromFile(waveFile, wave.x, marker);
vector mask_norm = normalizev(mask_from_file, MASK_MIN, MASK_MAX);
mask = vector_resize(mask_norm, len);
freev(mask_norm);
freev(mask_from_file);
qDebug() << "vector_resize" << LOG_DATA;
}
if (!tryFileData || !validateMask(mask)) {
qDebug() << "!tryFileData" << LOG_DATA;
mask = onesv(len);
}
return mask;
}
///////////////////////////////////////////////////////////////////////
// Class : CPointHierarchy
// Method : average
// Description :
/// \brief Create an internal node by averaging the point data
// Return Value : -
// Comments :
int CPointHierarchy::average(int numItems,int *indices) {
CMapNode node;
// PASS 1: Average the position/normal
initv(node.P,0);
initv(node.N,0);
for (int i=numItems;i>0;i--) {
const CPointCloudPoint *item = CMap<CPointCloudPoint>::items + (*indices++);
addvv(node.P,item->P);
addvv(node.N,item->N);
}
indices -= numItems;
// Normalize the thing
assert(numItems > 0);
mulvf(node.P,1/(float) numItems);
normalizev(node.N);
// PASS 2: Compute the maximum deviation
initv(node.radiosity,0);
node.dP = 0;
node.dN = 1;
for (int i=numItems;i>0;i--) {
vector D;
const CPointCloudPoint *item = CMap<CPointCloudPoint>::items + (*indices++);
const float *src = data.array + item->entryNumber;
float area;
subvv(D,node.P,item->P);
if (areaIndex == -1) area = max(((float) C_PI*item->dP*item->dP*dotvv(node.N,item->N)),0);
else area = max((src[areaIndex]*dotvv(node.N,item->N)),0);
node.dP += area;
if (radiosityIndex != -1) {
vector tmp;
mulvf(tmp,src + radiosityIndex,area);
addvv(node.radiosity,tmp);
}
node.dN = min(node.dN,dotvv(node.N,item->N));
}
indices -= numItems;
// Normalize the radiosity and the area
mulvf(node.radiosity,1 / node.dP); // Normalize the radiosity
node.dP = sqrtf(node.dP / (float) C_PI); // Convert to effective radius
// Create the node
nodes.push(node);
return nodes.numItems - 1;
}
vector data_get_intensive_derivative(SimpleGraphData * data)
{
if (data->b_derivative_intensive_norm == 0)
{
vector intensive = data_get_intensive_norm(data);
vector derivative_intensive = derivativev(intensive);
data->d_derivative_intensive_norm = normalizev(derivative_intensive, MASK_MIN, MASK_MAX);
freev(derivative_intensive);
data->b_derivative_intensive_norm == 1;
}
return data->d_derivative_intensive_norm;
}
///////////////////////////////////////////////////////////////////////
// Class : CIrradianceCache
// Method : sample
// Description : Sample the occlusion
// Return Value :
// Comments :
void CIrradianceCache::sample(float *C,const float *P,const float *dPdu,const float *dPdv,const float *N,CShadingContext *context) {
CCacheSample *cSample;
int i,j;
float coverage;
vector irradiance;
vector envdir;
float rMean;
CRay ray;
vector X,Y;
CCacheNode *cNode;
int depth;
// Allocate memory
const CShadingScratch *scratch = &(context->currentShadingState->scratch);
const int nt = (int) (sqrtf(scratch->traceParams.samples / (float) C_PI) + 0.5);
const int np = (int) (C_PI*nt + 0.5);
const int numSamples = nt*np;
CHemisphereSample *hemisphere = (CHemisphereSample *) alloca(numSamples*sizeof(CHemisphereSample));
// initialize texture lookups if needed
if (scratch->occlusionParams.environment) {
CTextureLookup::staticInit(&(context->currentShadingState->scratch));
}
// Create an orthanormal coordinate system
if (dotvv(dPdu,dPdu) > 0) {
normalizevf(X,dPdu);
crossvv(Y,N,X);
} else if (dotvv(dPdv,dPdv) > 0) {
normalizevf(X,dPdv);
crossvv(Y,N,X);
} else {
// At this point, we're pretty screwed, so why not use the P
normalizevf(X,P);
crossvv(Y,N,X);
}
// Sample the hemisphere
coverage = 0;
initv(irradiance,0);
initv(envdir,0);
rMean = C_INFINITY;
// Calculate the ray differentials (use average spread in theta and phi)
const float da = tanf((float) C_PI/(2*(nt+np)));
const float db = (lengthv(dPdu) + lengthv(dPdv))*0.5f;
if (scratch->occlusionParams.occlusion == TRUE) {
// We're shading for occlusion
context->numOcclusionRays += numSamples;
context->numOcclusionSamples++;
for (i=0;i<nt;i++) {
for (j=0;j<np;j++,hemisphere++) {
float rv[2];
context->random2d.get(rv);
float tmp = sqrtf((i+context->urand()) / (float) nt);
const float phi = (float) (2*C_PI*(j+context->urand()) / (float) np);
const float cosPhi = (cosf(phi)*tmp);
const float sinPhi = (sinf(phi)*tmp);
tmp = sqrtf(1 - tmp*tmp);
ray.dir[0] = X[0]*cosPhi + Y[0]*sinPhi + N[0]*tmp;
ray.dir[1] = X[1]*cosPhi + Y[1]*sinPhi + N[1]*tmp;
ray.dir[2] = X[2]*cosPhi + Y[2]*sinPhi + N[2]*tmp;
const float originJitterX = (rv[0] - 0.5f)*scratch->traceParams.sampleBase;
const float originJitterY = (rv[1] - 0.5f)*scratch->traceParams.sampleBase;
ray.from[COMP_X] = P[COMP_X] + originJitterX*dPdu[0] + originJitterY*dPdv[0];
ray.from[COMP_Y] = P[COMP_Y] + originJitterX*dPdu[1] + originJitterY*dPdv[1];
ray.from[COMP_Z] = P[COMP_Z] + originJitterX*dPdu[2] + originJitterY*dPdv[2];
ray.flags = ATTRIBUTES_FLAGS_DIFFUSE_VISIBLE;
ray.tmin = scratch->traceParams.bias;
ray.t = scratch->traceParams.maxDist;
ray.time = 0;
ray.da = da;
ray.db = db;
// Transform the ray into the right coordinate system
mulmp(ray.from,from,ray.from);
mulmv(ray.dir,from,ray.dir);
context->trace(&ray);
// Do we have an intersection ?
if (ray.object != NULL) {
const float *color = ray.object->attributes->surfaceColor;
// Yes
coverage++;
addvv(irradiance,color);
hemisphere->coverage = 1;
initv(hemisphere->envdir,0);
movvv(hemisphere->irradiance,color);
} else {
// No
hemisphere->coverage = 0;
addvv(envdir,ray.dir);
movvv(hemisphere->envdir,ray.dir);
// GSH : Texture lookup for misses
if(scratch->occlusionParams.environment != NULL){
CEnvironment *tex = scratch->occlusionParams.environment;
vector D0,D1,D2,D3;
vector color;
// GSHTODO: Add in the dCosPhi and dSinPhi
movvv(D0,ray.dir);
movvv(D1,ray.dir);
movvv(D2,ray.dir);
movvv(D3,ray.dir);
float savedSamples = scratch->traceParams.samples;
context->currentShadingState->scratch.traceParams.samples = 1;
tex->lookup(color,D0,D1,D2,D3,context);
context->currentShadingState->scratch.traceParams.samples = savedSamples;
addvv(irradiance,color);
movvv(hemisphere->irradiance,color);
} else{
initv(hemisphere->irradiance,0);
}
}
hemisphere->depth = ray.t;
hemisphere->invDepth = 1 / ray.t;
if (tmp > horizonCutoff) rMean = min(rMean,ray.t);
movvv(hemisphere->dir,ray.dir);
assert(hemisphere->invDepth > 0);
}
}
} else {
// We're shading for indirectdiffuse
context->numIndirectDiffuseRays += numSamples;
context->numIndirectDiffuseSamples++;
for (i=0;i<nt;i++) {
for (j=0;j<np;j++,hemisphere++) {
float rv[2];
context->random2d.get(rv);
float tmp = sqrtf((i+context->urand()) / (float) nt);
const float phi = (float) (2*C_PI*(j+context->urand()) / (float) np);
const float cosPhi = (cosf(phi)*tmp);
const float sinPhi = (sinf(phi)*tmp);
tmp = sqrtf(1 - tmp*tmp);
ray.dir[0] = X[0]*cosPhi + Y[0]*sinPhi + N[0]*tmp;
ray.dir[1] = X[1]*cosPhi + Y[1]*sinPhi + N[1]*tmp;
ray.dir[2] = X[2]*cosPhi + Y[2]*sinPhi + N[2]*tmp;
const float originJitterX = (rv[0] - 0.5f)*scratch->traceParams.sampleBase;
const float originJitterY = (rv[1] - 0.5f)*scratch->traceParams.sampleBase;
ray.from[COMP_X] = P[COMP_X] + originJitterX*dPdu[0] + originJitterY*dPdv[0];
ray.from[COMP_Y] = P[COMP_Y] + originJitterX*dPdu[1] + originJitterY*dPdv[1];
ray.from[COMP_Z] = P[COMP_Z] + originJitterX*dPdu[2] + originJitterY*dPdv[2];
ray.flags = ATTRIBUTES_FLAGS_DIFFUSE_VISIBLE;
ray.tmin = scratch->traceParams.bias;
ray.t = scratch->traceParams.maxDist;
ray.time = 0;
ray.da = da;
ray.db = db;
// Transform the ray into the right coordinate system
mulmp(ray.from,from,ray.from);
mulmv(ray.dir,from,ray.dir);
context->trace(&ray);
// Do we have an intersection ?
if (ray.object != NULL) {
vector P,N,C;
CAttributes *attributes = ray.object->attributes;
CPhotonMap *globalMap;
if ((globalMap = attributes->globalMap) != NULL) {
normalizev(N,ray.N);
mulvf(P,ray.dir,ray.t);
addvv(P,ray.from);
if(dotvv(ray.dir,N) > 0)
mulvf(N,-1);
globalMap->lookup(C,P,N,attributes->photonEstimator);
// HACK: Avoid too bright spots
tmp = max(max(C[0],C[1]),C[2]);
if (tmp > scratch->occlusionParams.maxBrightness) mulvf(C,scratch->occlusionParams.maxBrightness/tmp);
mulvv(C,attributes->surfaceColor);
addvv(irradiance,C);
movvv(hemisphere->irradiance,C);
context->numIndirectDiffusePhotonmapLookups++;
} else {
initv(hemisphere->irradiance,0);
}
// Yes
coverage++;
hemisphere->coverage = 1;
initv(hemisphere->envdir,0);
} else {
// No
hemisphere->coverage = 0;
addvv(envdir,ray.dir);
movvv(hemisphere->envdir,ray.dir);
// GSH : Texture lookup for misses
if(scratch->occlusionParams.environment != NULL){
CEnvironment *tex = scratch->occlusionParams.environment;
vector D0,D1,D2,D3;
vector color;
// GSHTODO: Add in the dCosPhi and dSinPhi
movvv(D0,ray.dir);
movvv(D1,ray.dir);
movvv(D2,ray.dir);
movvv(D3,ray.dir);
float savedSamples = scratch->traceParams.samples;
context->currentShadingState->scratch.traceParams.samples = 1;
tex->lookup(color,D0,D1,D2,D3,context);
context->currentShadingState->scratch.traceParams.samples = savedSamples;
addvv(irradiance,color);
movvv(hemisphere->irradiance,color);
} else{
movvv(hemisphere->irradiance,scratch->occlusionParams.environmentColor);
addvv(irradiance,scratch->occlusionParams.environmentColor);
}
}
hemisphere->depth = ray.t;
hemisphere->invDepth = 1 / ray.t;
if (tmp > horizonCutoff) rMean = min(rMean,ray.t);
movvv(hemisphere->dir,ray.dir);
assert(hemisphere->invDepth > 0);
}
}
}
hemisphere -= np*nt;
// Normalize
const float tmp = 1 / (float) numSamples;
coverage *= tmp;
mulvf(irradiance,tmp);
normalizevf(envdir);
// Record the value
C[0] = irradiance[0];
C[1] = irradiance[1];
C[2] = irradiance[2];
C[3] = coverage;
C[4] = envdir[0];
C[5] = envdir[1];
C[6] = envdir[2];
// Should we save it ?
if ((scratch->occlusionParams.maxError != 0) && (coverage < 1-C_EPSILON)) {
// We're modifying, lock the thing
osLock(mutex);
// Create the sample
cSample = (CCacheSample *) memory->alloc(sizeof(CCacheSample));
// Compute the gradients of the illumination
posGradient(cSample->gP,np,nt,hemisphere,X,Y);
rotGradient(cSample->gR,np,nt,hemisphere,X,Y);
// Compute the radius of validity
rMean *= 0.5f;
// Clamp the radius of validity
rMean = min(rMean,db*scratch->occlusionParams.maxPixelDist);
// Record the data (in the target coordinate system)
movvv(cSample->P,P);
movvv(cSample->N,N);
cSample->dP = rMean;
cSample->coverage = coverage;
movvv(cSample->envdir,envdir);
movvv(cSample->irradiance,irradiance);
// Do the neighbour clamping trick
clamp(cSample);
rMean = cSample->dP; // copy dP back so we get the right place in the octree
// The error multiplier
const float K = 0.4f / scratch->occlusionParams.maxError;
rMean /= K;
// Insert the new sample into the cache
cNode = root;
depth = 0;
while(cNode->side > (2*rMean)) {
depth++;
for (j=0,i=0;i<3;i++) {
if (P[i] > cNode->center[i]) {
j |= 1 << i;
}
}
if (cNode->children[j] == NULL) {
CCacheNode *nNode = (CCacheNode *) memory->alloc(sizeof(CCacheNode));
for (i=0;i<3;i++) {
if (P[i] > cNode->center[i]) {
nNode->center[i] = cNode->center[i] + cNode->side*0.25f;
} else {
nNode->center[i] = cNode->center[i] - cNode->side*0.25f;
}
}
cNode->children[j] = nNode;
nNode->side = cNode->side*0.5f;
nNode->samples = NULL;
for (i=0;i<8;i++) nNode->children[i] = NULL;
}
cNode = cNode->children[j];
}
cSample->next = cNode->samples;
cNode->samples = cSample;
maxDepth = max(depth,maxDepth);
osUnlock(mutex);
}
}
SimpleGraphData * SimpleProcWave2Data(QString fname, bool keepWaveData)
{
qDebug() << "::SimpleProcWave2Data" << LOG_DATA;
SPTK_SETTINGS * sptk_settings = SettingsDialog::getSPTKsettings();
SimpleGraphData * data = new SimpleGraphData();
data->b_pitch = 0;
data->b_pitch_log = 0;
data->b_pitch_derivative = 0;
data->b_intensive = 0;
data->b_intensive_cutted = 0;
data->b_intensive_norm = 0;
data->b_intensive_smooth = 0;
data->b_derivative_intensive_norm = 0;
data->b_spec = 0;
data->b_cepstrum = 0;
data->b_pitch_norm = 0;
QFile file(fname);
qDebug() << "::SimpleProcWave2Data QFile" << fname << LOG_DATA;
file.open(QIODevice::ReadOnly);
qDebug() << "::SimpleProcWave2Data file.open " << file.isOpen() << LOG_DATA;
WaveFile * waveFile = waveOpenHFile(file.handle());
qDebug() << "::SimpleProcWave2Data waveOpenFile" << LOG_DATA;
data->file_data = waveFile;
int size = littleEndianBytesToUInt32(waveFile->dataChunk->chunkDataSize);
qDebug() << "::SimpleProcWave2Data chunkDataSize " << size << LOG_DATA;
short int bits = littleEndianBytesToUInt16(waveFile->formatChunk->significantBitsPerSample);
qDebug() << "::SimpleProcWave2Data significantBitsPerSample " << bits << LOG_DATA;
double seconds = 1.0 * size / RECORD_FREQ / bits * CHAR_BIT;
qDebug() << "::SimpleProcWave2Data seconds=" << seconds << LOG_DATA;
data->seconds = seconds;
vector wave = sptk_v2v(waveFile->dataChunk->waveformData, size, bits);
qDebug() << "::SimpleProcWave2Data wave" << LOG_DATA;
vector norm_wave = normalizev(wave, 0.0, 1.0);
qDebug() << "::SimpleProcWave2Data norm_wave" << LOG_DATA;
data->d_full_wave = norm_wave;
vector frame = sptk_frame(wave, sptk_settings->frame);
qDebug() << "::SimpleProcWave2Data frame" << LOG_DATA;
vector intensive = vector_intensive(wave, sptk_settings->frame->leng, sptk_settings->frame->shift);
qDebug() << "::SimpleProcWave2Data intensive" << LOG_DATA;
data->d_intensive_original = intensive;
vector window = sptk_window(frame, sptk_settings->window);
qDebug() << "::SimpleProcWave2Data window" << LOG_DATA;
vector lpc = sptk_lpc(frame, sptk_settings->lpc);
qDebug() << "::SimpleProcWave2Data lpc " << lpc.x << LOG_DATA;
vector lpc2c = sptk_lpc2c(lpc, sptk_settings->lpc);
qDebug() << "::SimpleProcWave2Data lpc2c " << lpc2c.x;
data->d_cepstrum = lpc2c;
data->b_cepstrum = 1;
vector spec = sptk_spec(lpc, sptk_settings->spec);
qDebug() << "::SimpleProcWave2Data spec " << maxv(spec) << LOG_DATA;
data->d_spec = spec;
data->b_spec = 1;
vector spec_proc;
if (sptk_settings->spec->proc == 0){
spec_proc = vector_pow_log(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "::SimpleProcWave2Data spec_log" << LOG_DATA;
} else if (sptk_settings->spec->proc == 1){
spec_proc = vector_pow_exp(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "::SimpleProcWave2Data spec_exp" << LOG_DATA;
}
qDebug() << "::SimpleProcWave2Data spec_proc " << maxv(spec_proc) << LOG_DATA;
data->d_spec_proc = spec_proc;
vector smooth_wave = vector_smooth_lin(wave, sptk_settings->dp->smooth_frame);
vector pitch = processZeros(sptk_pitch_spec(smooth_wave, sptk_settings->pitch, intensive.x));
qDebug() << "::SimpleProcWave2Data pitch" << LOG_DATA;
data->d_pitch_original = pitch;
int otype = sptk_settings->pitch->OTYPE;
sptk_settings->pitch->OTYPE = 2;
vector pitch_log = sptk_pitch_spec(smooth_wave, sptk_settings->pitch, intensive.x);
sptk_settings->pitch->OTYPE = otype;
vector pitch_log_norm = normalizev(pitch_log, MASK_MIN, MASK_MAX);
qDebug() << "::SimpleProcWave2Data pitch_log" << LOG_DATA;
data->d_pitch_log = pitch_log_norm;
data->b_pitch_log = 1;
data->d_intensive = data_get_intensive(data);
data->d_intensive_norm = data_get_intensive_norm(data);
vector file_mask;
WaveFile * procFile = waveFile;
if (sptk_settings->dp->auto_marking)
{
procFile = selectMarkoutAlgorithm(data);
}
file_mask = getFileMask(procFile, wave, pitch.x);
data->md_p = getLabelsFromFile(procFile, MARK_PRE_NUCLEUS);
data->md_n = getLabelsFromFile(procFile, MARK_NUCLEUS);
data->md_t = getLabelsFromFile(procFile, MARK_POST_NUCLEUS);
if (sptk_settings->dp->auto_marking)
{
waveCloseFile(procFile);
}
qDebug() << "::SimpleProcWave2Data file_mask" << LOG_DATA;
vector mask_and = vector_mask_and(pitch_log_norm, file_mask);
vector mask = vector_smooth_mid(mask_and, 10);
qDebug() << "::SimpleProcWave2Data mask" << LOG_DATA;
data->d_mask = mask;
vector inverted_mask = vector_invert_mask(mask);
qDebug() << "::SimpleProcWave2Data inverted_mask" << LOG_DATA;
vector pitch_interpolate = vector_interpolate_by_mask(
pitch,
inverted_mask,
0,
sptk_settings->plotF0->interpolation_type
);
qDebug() << "::SimpleProcWave2Data pitch_interpolate" << LOG_DATA;
vector pitch_mid = vector_smooth_mid(pitch_interpolate, sptk_settings->plotF0->frame);
qDebug() << "::SimpleProcWave2Data pitch_mid" << LOG_DATA;
data->d_pitch = pitch_mid;
data->b_pitch = 1;
data->d_derivative_intensive_norm = data_get_intensive_derivative(data);
freev(frame);
freev(window);
freev(lpc);
freev(wave);
freev(pitch_interpolate);
freev(inverted_mask);
freev(smooth_wave);
freev(pitch_log);
freev(file_mask);
freev(mask_and);
qDebug() << "::SimpleProcWave2Data freev" << LOG_DATA;
file.close();
qDebug() << "::SimpleProcWave2Data file.close" << LOG_DATA;
if (keepWaveData)
{
waveFile->file = NULL;
} else {
data->file_data = NULL;
waveCloseFile(waveFile);
qDebug() << "::SimpleProcWave2Data waveCloseFile" << LOG_DATA;
}
return data;
}
GraphData * ProcWave2Data(QString fname)
{
SPTK_SETTINGS * sptk_settings = SettingsDialog::getSPTKsettings();
QFile file(fname);
file.open(QIODevice::ReadOnly);
WaveFile * waveFile = waveOpenHFile(file.handle());
qDebug() << "waveOpenFile" << LOG_DATA;
int size = littleEndianBytesToUInt32(waveFile->dataChunk->chunkDataSize);
qDebug() << "chunkDataSize" << LOG_DATA;
short int bits = littleEndianBytesToUInt16(waveFile->formatChunk->significantBitsPerSample);
qDebug() << "significantBitsPerSample" << LOG_DATA;
vector wave = sptk_v2v(waveFile->dataChunk->waveformData, size, bits);
qDebug() << "wave" << LOG_DATA;
vector frame = sptk_frame(wave, sptk_settings->frame);
qDebug() << "frame" << LOG_DATA;
vector intensive = vector_intensive(frame, sptk_settings->frame->leng, sptk_settings->frame->shift);
qDebug() << "intensive" << LOG_DATA;
vector window = sptk_window(frame, sptk_settings->window);
qDebug() << "window" << LOG_DATA;
vector lpc = sptk_lpc(frame, sptk_settings->lpc);
qDebug() << "lpc" << LOG_DATA;
vector spec = sptk_spec(lpc, sptk_settings->spec);
qDebug() << "spec " << maxv(spec) << LOG_DATA;
vector spec_proc;
if (sptk_settings->spec->proc == 0){
spec_proc = vector_pow_log(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_log" << LOG_DATA;
} else if (sptk_settings->spec->proc == 1){
spec_proc = vector_pow_exp(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_exp" << LOG_DATA;
}
qDebug() << "spec_proc " << maxv(spec_proc) << LOG_DATA;
vector pitch = processZeros(sptk_pitch_spec(wave, sptk_settings->pitch, intensive.x));
qDebug() << "pitch" << LOG_DATA;
vector mask = getFileMask(waveFile, wave, pitch.x);
qDebug() << "mask" << LOG_DATA;
vector pitch_cutted = processZeros(vector_cut_by_mask(pitch, mask));
qDebug() << "pitch_cutted" << LOG_DATA;
double pitch_min = getv(pitch_cutted, minv(pitch_cutted));
double pitch_max = getv(pitch_cutted, maxv(pitch_cutted));
vector intensive_cutted = vector_cut_by_mask(intensive, mask);
qDebug() << "intensive_cutted" << LOG_DATA;
vector inverted_mask = vector_invert_mask(mask);
qDebug() << "inverted_mask" << LOG_DATA;
vector pitch_interpolate = vector_interpolate_by_mask(
pitch_cutted,
inverted_mask,
0,
sptk_settings->plotF0->interpolation_type
);
qDebug() << "pitch_interpolate" << LOG_DATA;
vector intensive_interpolate = vector_interpolate_by_mask(
intensive_cutted,
inverted_mask,
0,
sptk_settings->plotEnergy->interpolation_type
);
qDebug() << "intensive_interpolate" << LOG_DATA;
vector pitch_mid = vector_smooth_mid(pitch_interpolate, sptk_settings->plotF0->frame);
qDebug() << "pitch_mid" << LOG_DATA;
vector intensive_mid = vector_smooth_lin(intensive_interpolate, sptk_settings->plotEnergy->frame);
qDebug() << "intensive_mid" << LOG_DATA;
vector norm_wave = normalizev(wave, 0.0, 1.0);
MaskData md_p = getLabelsFromFile(waveFile, MARK_PRE_NUCLEUS);
MaskData md_n = getLabelsFromFile(waveFile, MARK_NUCLEUS);
MaskData md_t = getLabelsFromFile(waveFile, MARK_POST_NUCLEUS);
vector p_mask = readMaskFromFile(waveFile, wave.x, MARK_PRE_NUCLEUS);
qDebug() << "p_mask" << LOG_DATA;
vector n_mask = readMaskFromFile(waveFile, wave.x, MARK_NUCLEUS);
qDebug() << "n_mask" << LOG_DATA;
vector t_mask = readMaskFromFile(waveFile, wave.x, MARK_POST_NUCLEUS);
qDebug() << "t_mask" << LOG_DATA;
vector p_wave = zero_to_nan(vector_cut_by_mask(norm_wave, p_mask));
qDebug() << "p_mask" << LOG_DATA;
vector n_wave = zero_to_nan(vector_cut_by_mask(norm_wave, n_mask));
qDebug() << "n_mask" << LOG_DATA;
vector t_wave = zero_to_nan(vector_cut_by_mask(norm_wave, t_mask));
qDebug() << "t_mask" << LOG_DATA;
vector pnt_mask = onesv(norm_wave.x);
for (int i=0; i<p_mask.x && i<n_mask.x && i<t_mask.x && i<norm_wave.x; i++) {
if (getv(p_mask, i) == 1 || getv(n_mask, i) == 1 || getv(t_mask, i) == 1)
{
setv(pnt_mask, i, 0);
} else {
setv(pnt_mask, i, 1);
}
}
vector display_wave = zero_to_nan(vector_cut_by_mask(norm_wave, pnt_mask));
freev(frame);
freev(window);
freev(lpc);
freev(pitch_cutted);
freev(intensive_cutted);
freev(inverted_mask);
freev(pitch_interpolate);
freev(intensive_interpolate);
freev(wave);
qDebug() << "freev" << LOG_DATA;
file.close();
waveCloseFile(waveFile);
qDebug() << "waveCloseFile" << LOG_DATA;
GraphData * data = new GraphData();
data->d_full_wave = norm_wave;
data->d_wave = display_wave;
data->d_p_wave = p_wave;
data->d_n_wave = n_wave;
data->d_t_wave = t_wave;
data->d_pitch_original = pitch;
data->d_pitch = pitch_mid;
data->pitch_max = pitch_max;
data->pitch_min = pitch_min;
data->d_intensive_original = intensive;
data->d_intensive = intensive_mid;
data->d_spec_proc = spec_proc;
data->d_spec = spec;
data->d_mask = mask;
data->p_mask = p_mask;
data->n_mask = n_mask;
data->t_mask = t_mask;
data->pnt_mask = pnt_mask;
data->md_p = md_p;
data->md_t = md_t;
data->md_n = md_n;
return data;
}
