Beispiel #1
0
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 */
  /* } */
}
Beispiel #3
0
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;
}
Beispiel #4
0
/*
 * 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 */
}