real_T bisection2(real_T a, real_T b, real_T tol) { real_T p; const mxArray *y; static const int32_T iv0[2] = { 1, 16 }; const mxArray *m0; static const char_T cv0[16] = { 'W', 'r', 'o', 'n', 'g', ' ', 'c', 'h', 'o', 'i', 'c', 'e', ' ', 'b', 'r', 'o' }; real_T err; /* provide the equation you want to solve with R.H.S = 0 form. */ /* Write the L.H.S by using inline function */ /* Give initial guesses. */ /* Solves it by method of bisection. */ /* A very simple code and very handy! */ if ((muDoubleScalarPower(a - 1.5, 3.0) + 10.0) * (muDoubleScalarPower(b - 1.5, 3.0) + 10.0) > 0.0) { EMLRTPUSHRTSTACK(&emlrtRSI); EMLRTPUSHRTSTACK(&b_emlrtRSI); y = NULL; m0 = mxCreateCharArray(2, iv0); emlrtInitCharArray(16, m0, cv0); emlrtAssign(&y, m0); error(y, &emlrtMCI); EMLRTPOPRTSTACK(&b_emlrtRSI); EMLRTPOPRTSTACK(&emlrtRSI); } else { p = (a + b) / 2.0; err = muDoubleScalarAbs(b - a); while (err >= tol) { if ((muDoubleScalarPower(a - 1.5, 3.0) + 10.0) * (muDoubleScalarPower(p - 1.5, 3.0) + 10.0) < 0.0) { b = p; } else { a = p; } p = (a + b) / 2.0; err = muDoubleScalarAbs(b - a); emlrtBreakCheck(); } } return p; }
void drr_SK_Simplified(const emxArray_boolean_T *voxel_data, const real_T voxel_size_mm[3], const real_T detector_dimensions[2], real_T pixel_size_mm, const real_T voxel_corner_min[3], const real_T T_carm[16], emxArray_real_T *projection) { int32_T ix; int32_T i; uint32_T voxDim[3]; real_T voxPlanes__max[3]; real_T source[3]; real_T pixel_size_mmel__hn[3]; real_T pixel_size_mmel__wn[3]; real_T corner[3]; real_T b_ix; real_T iy; int32_T ih; int32_T iw; real_T tnext[3]; real_T tstep[3]; real_T b_voxPlanes__max[3]; real_T ray_source2pixel[3]; real_T b_ray_source2pixel[3]; real_T pixel_point_mm[3]; real_T t_plane_min[3]; real_T t_plane_max[3]; boolean_T exitg8; boolean_T exitg7; real_T iz; boolean_T exitg6; real_T t_larger[4]; boolean_T exitg5; boolean_T exitg4; boolean_T exitg3; real_T t_smaller[4]; real_T temp; int32_T itmp; boolean_T exitg2; real_T tmax; boolean_T exitg1; real_T tx; real_T ty; real_T tz; /* function [projection] = drr (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, isocenter_mm, cbct_angles_deg) */ /* Creates a 2D projection at each cbct_angle of voxel_data. the projection */ /* axis is defined by the isocenter to which the source and center of */ /* the detector are aligned. This simulation assumes standard Cone Beam CT */ /* geometry (source to isocenter distance is 100 cm and source to detector */ /* distance is 150cm). */ /* */ /* voxel_data: must be a 3 dimensional matrix (typically of CT data) */ /* voxel_size_mm: a 3 element vector listing the size (in mm) of the voxels */ /* along each dimension */ /* detector_dimension: a 2 element vector listing the dimensions (number of */ /* pixels) in each dimension (u,v) */ /* pixel_size_mm: a number defining the height and width of each pixel */ /* (assumes square pixel) */ /* isocenter_mm: a 3 element vector pointing from the origin (corner) of the */ /* matrix element(1,1,1) to the isocenter */ /* cbct_angles_deg: a list of angles to generate projections */ /* */ /* Retrun Variable */ /* projection: a 3D matrix with the 3rd dimension representing the angle of */ /* roatation */ /* */ /* { */ /* Author: Michael M. Folkerts [email protected] */ /* Institution: UCSD Physics, UTSW Radiation Oncology */ /* Updated: 2014-July. */ /* Notes: Siddon's Incremental algorithm | modified to read in 3D matlab matrix | Simplified Input | No guarantees!! */ /* */ /* References: */ /* R.L. Siddon, */ /* "Fast calculation of the exact radiological path for a three-dimensional CT */ /* array," Medical Physics 12, 252-255 (1985). */ /* */ /* F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens and I. Lemahieu, */ /* "A fast algorithm to calculate the exact radiological path through a pixel_size_mmel or voxel space," */ /* Journal of Computing and Information Technology 6, 89-94 (1998). */ /* */ /* G. Han, Z. Liang and J. You, */ /* "A fast ray tracing technique for TCT and ECT studies," */ /* IEEE Medical Imaging Conference 1999. */ /* } */ /* if(0) */ /* voxel_data = OUTPUTgrid; */ /* voxel_size_mm = voxel_size; */ /* detector_dimensions = detector_dimension; */ /* pixel_size_mm = pixel_size; */ /* isocenter_mm = isocenter; */ /* T_carm: Transformation matrix of C-arm (that is set at the middle of */ /* detector & source) with respect to Voxel coordinates */ /* tic; */ /* this will verify the size: */ if (eml_ndims_varsized(*(int32_T (*)[3])voxel_data->size) != 3) { EMLRTPUSHRTSTACK(&emlrtRSI); error(); EMLRTPOPRTSTACK(&emlrtRSI); } /* constants: */ /* .0001; */ /* .0001; */ /* sounce to imager(detector) distance */ /* source to axis distance %% RRI set the coordinate at the middle between source and the detector */ /* initialize memory for speed: */ ix = projection->size[0] * projection->size[1]; projection->size[0] = (int32_T)emlrtIntegerCheckR2009b (emlrtNonNegativeCheckR2009b(detector_dimensions[0], &b_emlrtDCI), &emlrtDCI); projection->size[1] = (int32_T)emlrtIntegerCheckR2009b (emlrtNonNegativeCheckR2009b(detector_dimensions[1], &d_emlrtDCI), &c_emlrtDCI); emxEnsureCapacity((emxArray__common *)projection, ix, (int32_T)sizeof(real_T), &emlrtRTEI); i = (int32_T)emlrtIntegerCheckR2009b(emlrtNonNegativeCheckR2009b (detector_dimensions[0], &f_emlrtDCI), &e_emlrtDCI) * (int32_T) emlrtIntegerCheckR2009b(emlrtNonNegativeCheckR2009b(detector_dimensions[1], &h_emlrtDCI), &g_emlrtDCI) - 1; for (ix = 0; ix <= i; ix++) { projection->data[ix] = 0.0; } for (ix = 0; ix < 3; ix++) { voxDim[ix] = (uint32_T)voxel_data->size[ix]; } /* [size(voxel_data,1), size(voxel_data,2), size(voxel_data,3)]; */ /* difine voxel boundaries: */ /* vector from origin to source */ /* vector from origin to CENTER of detector */ /* define pixel_size_mmel vectors: */ /* define upper lefthand corner of detector: */ for (i = 0; i < 3; i++) { voxPlanes__max[i] = voxel_corner_min[i] + voxel_size_mm[i] * (real_T) voxDim[i]; /* define up: */ /* up = [0,0,1]; */ /* width of projection image */ /* height of projection image */ /* direction from the detector to the source */ /* end initialization timer: */ /* init_time = toc */ /* start tracing timer: */ /* tic; */ source[i] = 550.0 * T_carm[4 + i] + T_carm[12 + i]; b_ix = -pixel_size_mm * T_carm[i]; /* length of pixel_size_mmel */ iy = pixel_size_mm * T_carm[8 + i]; /* vector pointing left, parallel to detector */ /* define incremental vectors: */ pixel_size_mmel__hn[i] = -iy; pixel_size_mmel__wn[i] = -b_ix; corner[i] = (-550.0 * T_carm[4 + i] + T_carm[12 + i]) + (detector_dimensions[0] * b_ix + detector_dimensions[1] * iy) / 2.0; } emlrtForLoopVectorCheckR2011b(1.0, 1.0, detector_dimensions[0], mxDOUBLE_CLASS, (int32_T)detector_dimensions[0], &d_emlrtRTEI, &emlrtContextGlobal, 0); ih = 0; while (ih <= (int32_T)detector_dimensions[0] - 1) { /* if(mod(ih,100)==0),fprintf('height:\t%i...\n',ih);end */ emlrtForLoopVectorCheckR2011b(1.0, 1.0, detector_dimensions[1], mxDOUBLE_CLASS, (int32_T)detector_dimensions[1], &c_emlrtRTEI, &emlrtContextGlobal, 0); iw = 0; while (iw <= (int32_T)detector_dimensions[1] - 1) { /* ray to be traced */ /* find parametrized (t) voxel plane (min or max) intersections: */ /* PLANE = P1 + t(P2-P1) */ /* SK added */ /* t_x = (i-x1) / (x2-x1), t_y = (j-y1) / (y2-y1), t_z = (k-z1) / (z2-z1) */ for (i = 0; i < 3; i++) { b_ix = (corner[i] + ((1.0 + (real_T)ih) - 1.0) * pixel_size_mmel__hn[i]) + ((1.0 + (real_T)iw) - 1.0) * pixel_size_mmel__wn[i]; /* ray end point */ iy = b_ix - source[i]; tnext[i] = voxel_corner_min[i] - source[i]; tstep[i] = iy + 2.2250738585072014E-308; b_voxPlanes__max[i] = voxPlanes__max[i] - source[i]; ray_source2pixel[i] = iy + 2.2250738585072014E-308; b_ray_source2pixel[i] = iy; pixel_point_mm[i] = b_ix; } rdivide(tnext, tstep, t_plane_min); rdivide(b_voxPlanes__max, ray_source2pixel, t_plane_max); /* compute (parametric) intersection values */ /* tmin = max { min{tx(0), tx(Nx)}, min{ty(0), ty(Ny)], min{tz(0), tz(Nz)}, 0.0 } */ /* tmax = min { max{tx(0), tx(Nx)}, max{ty(0), ty(Ny)], max{tz(0), tz(Nz)}, 1.0 } */ /* t_larger = [ max([t_plane_min(1), t_plane_max(1)]), max([t_plane_min(2), t_plane_max(2)]), max([t_plane_min(3), t_plane_max(3)]), 1.0 ]; */ /* t_smaller = [ min([t_plane_min(1), t_plane_max(1)]), min([t_plane_min(2), t_plane_max(2)]), min([t_plane_min(3), t_plane_max(3)]), 0.0 ]; */ i = 1; b_ix = t_plane_min[0]; if (muDoubleScalarIsNaN(t_plane_min[0])) { ix = 2; exitg8 = FALSE; while ((exitg8 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[0])) { b_ix = t_plane_max[0]; exitg8 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[0] > b_ix)) { b_ix = t_plane_max[0]; } i = 1; iy = t_plane_min[1]; if (muDoubleScalarIsNaN(t_plane_min[1])) { ix = 2; exitg7 = FALSE; while ((exitg7 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[1])) { iy = t_plane_max[1]; exitg7 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[1] > iy)) { iy = t_plane_max[1]; } i = 1; iz = t_plane_min[2]; if (muDoubleScalarIsNaN(t_plane_min[2])) { ix = 2; exitg6 = FALSE; while ((exitg6 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[2])) { iz = t_plane_max[2]; exitg6 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[2] > iz)) { iz = t_plane_max[2]; } t_larger[0] = b_ix; t_larger[1] = iy; t_larger[2] = iz; t_larger[3] = 1.0; i = 1; b_ix = t_plane_min[0]; if (muDoubleScalarIsNaN(t_plane_min[0])) { ix = 2; exitg5 = FALSE; while ((exitg5 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[0])) { b_ix = t_plane_max[0]; exitg5 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[0] < b_ix)) { b_ix = t_plane_max[0]; } i = 1; iy = t_plane_min[1]; if (muDoubleScalarIsNaN(t_plane_min[1])) { ix = 2; exitg4 = FALSE; while ((exitg4 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[1])) { iy = t_plane_max[1]; exitg4 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[1] < iy)) { iy = t_plane_max[1]; } i = 1; iz = t_plane_min[2]; if (muDoubleScalarIsNaN(t_plane_min[2])) { ix = 2; exitg3 = FALSE; while ((exitg3 == 0U) && (ix < 3)) { i = 2; if (!muDoubleScalarIsNaN(t_plane_max[2])) { iz = t_plane_max[2]; exitg3 = TRUE; } else { ix = 3; } } } if ((i < 2) && (t_plane_max[2] < iz)) { iz = t_plane_max[2]; } t_smaller[0] = b_ix; t_smaller[1] = iy; t_smaller[2] = iz; t_smaller[3] = 0.0; i = 1; temp = t_smaller[0]; itmp = 0; if (muDoubleScalarIsNaN(t_smaller[0])) { ix = 2; exitg2 = FALSE; while ((exitg2 == 0U) && (ix < 5)) { i = ix; if (!muDoubleScalarIsNaN(t_smaller[ix - 1])) { temp = t_smaller[ix - 1]; exitg2 = TRUE; } else { ix++; } } } if (i < 4) { while (i + 1 < 5) { if (t_smaller[i] > temp) { temp = t_smaller[i]; itmp = i; } i++; } } i = 1; tmax = t_larger[0]; if (muDoubleScalarIsNaN(t_larger[0])) { ix = 2; exitg1 = FALSE; while ((exitg1 == 0U) && (ix < 5)) { i = ix; if (!muDoubleScalarIsNaN(t_larger[ix - 1])) { tmax = t_larger[ix - 1]; exitg1 = TRUE; } else { ix++; } } } if (i < 4) { while (i + 1 < 5) { if (t_larger[i] < tmax) { tmax = t_larger[i]; } i++; } } for (ix = 0; ix < 3; ix++) { pixel_point_mm[ix] = (real_T)(pixel_point_mm[ix] < source[ix]) * -2.0 + 1.0; } if (temp < tmax) { /* if ray intersects volume */ /* find index for each dimension: */ for (i = 0; i < 3; i++) { b_ix = muDoubleScalarFloor((((b_ray_source2pixel[i] * temp + source[i]) - voxel_corner_min[i]) + 2.2250738585072014E-308) / voxel_size_mm[i]); /* (parametric) intersection values... */ /* makes 0 or 1 */ tnext[i] = (voxel_corner_min[i] + ((b_ix + (pixel_point_mm[i] + 1.0) / 2.0) * voxel_size_mm[i] - source[i])) / (b_ray_source2pixel[i] + 2.2250738585072014E-308); /* parametric value for next plane intersection */ iy = voxel_size_mm[i] / (b_ray_source2pixel[i] + 2.2250738585072014E-308); tstep[i] = muDoubleScalarAbs(iy); b_ray_source2pixel[i] = iy; t_plane_min[i] = b_ix; } /* parametric step size */ /* address special cases... */ if (temp == t_plane_max[emlrtBoundsCheck(itmp + 1, &c_emlrtBCI) - 1]) { /* if intersection is a "max" plane */ if (itmp + 1 == 1) { t_plane_min[0] = (real_T)voxDim[0] - 1.0; } else if (itmp + 1 == 2) { t_plane_min[1] = (real_T)voxDim[1] - 2.0; } else { t_plane_min[2] = (real_T)voxDim[2] - 2.0; } tnext[itmp] = temp + tstep[itmp]; /* next plane crossing */ } else { t_plane_min[itmp] = 0.0; tnext[itmp] = temp + tstep[itmp]; /* next plane crossing */ } /* voxel index values(add one for matlab): */ b_ix = t_plane_min[0] + 1.0; iy = t_plane_min[1] + 1.0; iz = t_plane_min[2] + 1.0; tx = tnext[0]; ty = tnext[1]; tz = tnext[2]; i = 0; /* uncomment to generate P-matrix: */ /* pixel_size_mmNum = 1; */ /* len = norm(ray_source2pixel); % ray length */ while ((temp + 0.0001 < tmax) && (!(b_ix * iy * iz == 0.0))) { if ((tx < ty) && (tx < tz)) { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ if (voxel_data->data[((emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(b_ix, &o_emlrtDCI), 1, voxel_data->size[0], &j_emlrtBCI) + voxel_data->size[0] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iy, &p_emlrtDCI), 1, voxel_data->size[1], &k_emlrtBCI) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iz, &q_emlrtDCI), 1, voxel_data-> size[2], &l_emlrtBCI) - 1)) - 1]) { i = 255; tmax = rtMinusInf; } temp = tx; tx += tstep[0]; b_ix += pixel_point_mm[0]; } else if (ty < tz) { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ if (voxel_data->data[((emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(b_ix, &l_emlrtDCI), 1, voxel_data->size[0], &g_emlrtBCI) + voxel_data->size[0] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iy, &m_emlrtDCI), 1, voxel_data->size[1], &h_emlrtBCI) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iz, &n_emlrtDCI), 1, voxel_data-> size[2], &i_emlrtBCI) - 1)) - 1]) { i = 255; tmax = rtMinusInf; } temp = ty; ty += tstep[1]; iy += pixel_point_mm[1]; } else { /* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */ if (voxel_data->data[((emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(b_ix, &i_emlrtDCI), 1, voxel_data->size[0], &d_emlrtBCI) + voxel_data->size[0] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iy, &j_emlrtDCI), 1, voxel_data->size[1], &e_emlrtBCI) - 1)) + voxel_data->size[0] * voxel_data->size[1] * (emlrtDynamicBoundsCheck((int32_T) emlrtIntegerCheckR2009b(iz, &k_emlrtDCI), 1, voxel_data-> size[2], &f_emlrtBCI) - 1)) - 1]) { i = 255; tmax = rtMinusInf; } temp = tz; tz += tstep[2]; iz += pixel_point_mm[2]; } emlrtBreakCheck(); } /* end while */ projection->data[(emlrtDynamicBoundsCheck((int32_T)(1.0 + (real_T)ih), 1, projection->size[0], &m_emlrtBCI) + projection->size[0] * (emlrtDynamicBoundsCheck((int32_T)(1.0 + (real_T)iw), 1, projection->size[1], &n_emlrtBCI) - 1)) - 1] = (real_T)i; } else { /* if no intersections */ projection->data[(emlrtDynamicBoundsCheck((int32_T)(1.0 + (real_T)ih), 1, projection->size[0], &emlrtBCI) + projection->size[0] * (emlrtDynamicBoundsCheck((int32_T)(1.0 + (real_T)iw), 1, projection->size[1], &b_emlrtBCI) - 1)) - 1] = 0.0; } /* if intersections */ /* uncomment to generate P-matrix: */ /* rayCount = rayCount + 1; */ iw++; emlrtBreakCheck(); } /* width */ /* fprintf('\n'); */ ih++; emlrtBreakCheck(); } /* height */ /* uncomment to generate P-matrix: */ /* matrix = matrix(1:mtxCount-1,:); */ /* stop trace timer: */ /* trace_time = toc */ /* fprintf('\n') */ /* function */ /* } */ }
real_T sum(const emxArray_real_T *x) { real_T y; boolean_T p; boolean_T b_p; int32_T k; int32_T exitg1; int32_T vlen; const mxArray *b_y; static const int32_T iv19[2] = { 1, 30 }; const mxArray *m4; static const char_T cv9[30] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o', 'l', 'b', 'o', 'x', ':', 's', 'u', 'm', '_', 's', 'p', 'e', 'c', 'i', 'a', 'l', 'E', 'm', 'p', 't', 'y' }; const mxArray *c_y; static const int32_T iv20[2] = { 1, 36 }; static const char_T cv10[36] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o', 'l', 'b', 'o', 'x', ':', 'a', 'u', 't', 'o', 'D', 'i', 'm', 'I', 'n', 'c', 'o', 'm', 'p', 'a', 't', 'i', 'b', 'i', 'l', 'i', 't', 'y' }; EMLRTPUSHRTSTACK(&pc_emlrtRSI); EMLRTPUSHRTSTACK(&sc_emlrtRSI); p = FALSE; EMLRTPUSHRTSTACK(&tc_emlrtRSI); EMLRTPUSHRTSTACK(&uc_emlrtRSI); b_p = FALSE; k = 0; do { exitg1 = 0U; if (k < 2) { vlen = x->size[k]; if (vlen != 0) { exitg1 = 1U; } else { k++; } } else { b_p = TRUE; exitg1 = 1U; } } while (exitg1 == 0U); EMLRTPOPRTSTACK(&uc_emlrtRSI); if (b_p) { b_p = TRUE; } else { b_p = FALSE; } EMLRTPOPRTSTACK(&tc_emlrtRSI); if (!b_p) { } else { p = TRUE; } EMLRTPOPRTSTACK(&sc_emlrtRSI); EMLRTPOPRTSTACK(&pc_emlrtRSI); if (!p) { b_p = TRUE; } else { b_p = FALSE; } if (b_p) { } else { EMLRTPUSHRTSTACK(&qc_emlrtRSI); b_y = NULL; m4 = mxCreateCharArray(2, iv19); emlrtInitCharArray(30, m4, cv9); emlrtAssign(&b_y, m4); error(message(b_y, &n_emlrtMCI), &o_emlrtMCI); EMLRTPOPRTSTACK(&qc_emlrtRSI); } if ((x->size[1] == 1) || (x->size[1] != 1)) { b_p = TRUE; } else { b_p = FALSE; } if (b_p) { } else { EMLRTPUSHRTSTACK(&rc_emlrtRSI); c_y = NULL; m4 = mxCreateCharArray(2, iv20); emlrtInitCharArray(36, m4, cv10); emlrtAssign(&c_y, m4); error(message(c_y, &p_emlrtMCI), &q_emlrtMCI); EMLRTPOPRTSTACK(&rc_emlrtRSI); } if (x->size[1] == 0) { y = 0.0; } else { vlen = x->size[1]; y = x->data[0]; for (k = 2; k <= vlen; k++) { y += x->data[emlrtDynamicBoundsCheck(k, 1, x->size[1], &ee_emlrtBCI) - 1]; } } return y; }
/* * function [frq,mr] = mel2frq(mel) */ void mel2frq(a_melcepstStackData *SD, const real_T mel[4], real_T frq[4]) { int32_T k; real_T x; /* MEL2FRQ Convert Mel frequency scale to Hertz FRQ=(MEL) */ /* frq = mel2frq(mel) converts a vector of Mel frequencies */ /* to the corresponding real frequencies. */ /* mr gives the corresponding gradients in Hz/mel. */ /* The Mel scale corresponds to the perceived pitch of a tone */ /* The relationship between mel and frq is given by: */ /* */ /* m = ln(1 + f/700) * 1000 / ln(1+1000/700) */ /* */ /* This means that m(1000) = 1000 */ /* */ /* References: */ /* */ /* [1] S. S. Stevens & J. Volkman "The relation of pitch to */ /* frequency", American J of Psychology, V 53, p329 1940 */ /* [2] C. G. M. Fant, "Acoustic description & classification */ /* of phonetic units", Ericsson Tchnics, No 1 1959 */ /* (reprinted in "Speech Sounds & Features", MIT Press 1973) */ /* [3] S. B. Davis & P. Mermelstein, "Comparison of parametric */ /* representations for monosyllabic word recognition in */ /* continuously spoken sentences", IEEE ASSP, V 28, */ /* pp 357-366 Aug 1980 */ /* [4] J. R. Deller Jr, J. G. Proakis, J. H. L. Hansen, */ /* "Discrete-Time Processing of Speech Signals", p380, */ /* Macmillan 1993 */ /* [5] HTK Reference Manual p73 */ /* */ /* Copyright (C) Mike Brookes 1998 */ /* Version: $Id: mel2frq.m,v 1.7 2010/08/01 08:41:57 dmb Exp $ */ /* */ /* VOICEBOX is a MATLAB toolbox for speech processing. */ /* Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html */ /* */ /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */ /* This program is free software; you can redistribute it and/or modify */ /* it under the terms of the GNU General Public License as published by */ /* the Free Software Foundation; either version 2 of the License, or */ /* (at your option) any later version. */ /* */ /* This program is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ /* GNU General Public License for more details. */ /* */ /* You can obtain a copy of the GNU General Public License from */ /* http://www.gnu.org/copyleft/gpl.html or by writing to */ /* Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA. */ /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */ /* 'mel2frq:55' if isempty(k) */ /* 'mel2frq:58' frq=700*sign(mel).*(exp(abs(mel)/k)-1); */ EMLRTPUSHRTSTACK(&ab_emlrtRSI); for (k = 0; k < 4; k++) { frq[k] = mel[k]; } for (k = 0; k < 4; k++) { x = frq[k]; if (frq[k] > 0.0) { x = 1.0; } else if (frq[k] < 0.0) { x = -1.0; } else { if (frq[k] == 0.0) { x = 0.0; } } frq[k] = x; } for (k = 0; k < 4; k++) { frq[k] = 700.0 * frq[k] * (muDoubleScalarExp(muDoubleScalarAbs(mel[k]) / SD->pd->b_k) - 1.0); } EMLRTPOPRTSTACK(&ab_emlrtRSI); /* 'mel2frq:59' mr=(700+abs(frq))/k; */ EMLRTPUSHRTSTACK(&bb_emlrtRSI); EMLRTPOPRTSTACK(&bb_emlrtRSI); /* 'mel2frq:60' if ~nargout */ }