sadwt.c

QccPack implementation in C

int QccWAVWaveletInverseShapeAdaptiveDWT1D(const QccVector input_signal,
                                           const QccVector input_mask,
                                           QccVector output_signal,
                                           QccVector output_mask,
                                           int signal_length,
                                           int num_scales,
                                           const QccWAVWavelet *wavelet)
{
  int return_value;
  int scale;
  QccVector temp_signal = NULL;
  QccVector temp_mask = NULL;
  QccVector subsequence = NULL;
  int current_length;
  
  if (input_signal == NULL)
    return(0);
  if (input_mask == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (output_mask == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  if (num_scales < 0)
    return(0);
  if (num_scales == 0)
    {
      QccVectorCopy(output_signal, input_signal, signal_length);
      QccVectorCopy(output_mask, input_mask, signal_length);
      return(0);
    }
  
  if ((temp_signal = QccVectorAlloc(signal_length)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorAlloc()");
      goto QccError;
    }
  if ((temp_mask = QccVectorAlloc(signal_length)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorAlloc()");
      goto QccError;
    }
  if ((subsequence = QccVectorAlloc(signal_length)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorAlloc()");
      goto QccError;
    }
  
  if (QccVectorCopy(temp_signal, input_signal, signal_length))
    {
      QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorCopy()");
      goto QccError;
    }
  if (QccVectorCopy(temp_mask, input_mask, signal_length))
    {
      QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorCopy()");
      goto QccError;
    }
  
  for (scale = num_scales - 1; scale >= 0 ; scale--)
    {
      current_length = 
        QccWAVWaveletDWTSubbandLength(signal_length, scale, 0, 0, 0);
      
      if (QccWAVWaveletShapeAdaptiveSynthesis1D(temp_signal,
                                                output_signal,
                                                subsequence,
                                                temp_mask,
                                                output_mask,
                                                current_length,
                                                wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccWAVWaveletShapeAdaptiveSynthesis1D()");
          goto QccError;
        }
      
      if (QccVectorCopy(temp_signal, output_signal, current_length))
        {
          QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorCopy()");
          goto QccError;
        }
      if (QccVectorCopy(temp_mask, output_mask, current_length))
        {
          QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveInverseDWT1D): Error calling QccVectorCopy()");
          goto QccError;
        }
    }
  
  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  QccVectorFree(temp_signal);
  QccVectorFree(temp_mask);
  QccVectorFree(subsequence);
  return(return_value);
  
}


int QccWAVWaveletShapeAdaptiveDWT2D(const QccMatrix input_data, 
                                    const QccMatrix input_mask, 
                                    QccMatrix output_data, 
                                    QccMatrix output_mask,
                                    int num_rows,
                                    int num_cols,
                                    int num_scales,
                                    const QccWAVWavelet *wavelet)
{
  int return_value;
  QccVector input_data_vector = NULL;
  QccVector output_data_vector = NULL;
  QccVector subsequence = NULL;
  QccVector input_mask_vector = NULL;
  QccVector output_mask_vector = NULL;
  int scale;
  int row, col;
  int baseband_num_rows;
  int baseband_num_cols;
  
  /* Allocate temporary working arrays */
  if ((input_data_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWaveletShapeAdaptiveDWT2D): Error calling VectorAlloc()");
      goto Error;
    }
  if ((output_data_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWaveletShapeAdaptiveDWT2D): Error calling VectorAlloc()");
      goto Error;
    }
  if ((subsequence =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWaveletShapeAdaptiveDWT2D): Error calling VectorAlloc()");
      goto Error;
    }
  if ((input_mask_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWaveletShapeAdaptiveDWT2D): Error calling VectorAlloc()");
      goto Error;
    }
  if ((output_mask_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWaveletShapeAdaptiveDWT2D): Error calling VectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    for (col = 0; col < num_cols; col++)
      {
        output_data[row][col] = input_data[row][col];
        output_mask[row][col] = input_mask[row][col];
      }
  
  for (scale = 0; scale < num_scales; scale++)
    {
      baseband_num_rows =
        QccWAVWaveletDWTSubbandLength(num_rows, scale, 0, 0, 0);
      baseband_num_cols =
        QccWAVWaveletDWTSubbandLength(num_cols, scale, 0, 0, 0);
      
      for (row = 0; row < baseband_num_rows; row++)
        {
          for (col = 0; col < baseband_num_cols; col++)
            {
              input_data_vector[col] = output_data[row][col];
              input_mask_vector[col] = output_mask[row][col];
            }
          
          if (QccWAVWaveletShapeAdaptiveAnalysis1D(input_data_vector,
                                                   output_data_vector,
                                                   subsequence,
                                                   input_mask_vector,
                                                   output_mask_vector,
                                                   baseband_num_cols,
                                                   wavelet))
            {
              QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveDWT2D): Error calling QccWAVWaveletShapeAdaptiveAnalysis1D()");
              goto Error;
            }
          
          for (col = 0; col < baseband_num_cols; col++)
            {
              output_data[row][col] = output_data_vector[col];
              output_mask[row][col] = output_mask_vector[col];
            }
        }
      
      for (col = 0; col < baseband_num_cols; col++)
        {
          for (row = 0; row < baseband_num_rows; row++)
            {
              input_data_vector[row] = output_data[row][col];
              input_mask_vector[row] = output_mask[row][col];
            }
          
          if (QccWAVWaveletShapeAdaptiveAnalysis1D(input_data_vector,
                                                   output_data_vector,
                                                   subsequence,
                                                   input_mask_vector,
                                                   output_mask_vector,
                                                   baseband_num_rows,
                                                   wavelet))
            {
              QccErrorAddMessage("(QccWAVWaveletShapeAdaptiveDWT2D): Error calling QccWAVWaveletShapeAdaptiveAnalysis1D()");
              goto Error;
            }
          
          for (row = 0; row < baseband_num_rows; row++)
            {
              output_data[row][col] = output_data_vector[row];
              output_mask[row][col] = output_mask_vector[row];
            }
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(input_data_vector);
  QccVectorFree(output_data_vector);
  QccVectorFree(subsequence);
  QccVectorFree(input_mask_vector);
  QccVectorFree(output_mask_vector);
  return(return_value);
} 


int QccWAVWaveletInverseShapeAdaptiveDWT2D(const QccMatrix input_data, 
                                           const QccMatrix input_mask, 
                                           QccMatrix output_data, 
                                           QccMatrix output_mask,
                                           int num_rows,
                                           int num_cols,
                                           int num_scales,
                                           const QccWAVWavelet *wavelet)
{
  int return_value;
  QccVector input_data_vector = NULL;
  QccVector output_data_vector = NULL;
  QccVector subsequence = NULL;
  QccVector input_mask_vector = NULL;
  QccVector output_mask_vector = NULL;
  int scale;
  int row, col;
  int baseband_num_rows;
  int baseband_num_cols;
  
  /* Allocate temporary working arrays */
  if ((input_data_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_data_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((subsequence =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((input_mask_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_mask_vector =
       QccVectorAlloc(QccMathMax(num_rows, num_cols))) == NULL)
    
    {
      QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    for (col = 0; col < num_cols; col++)
      {
        output_data[row][col] = input_data[row][col];
        output_mask[row][col] = input_mask[row][col];
      }
  
  for (scale = num_scales - 1; scale >= 0; scale--)
    {
      baseband_num_rows =
        QccWAVWaveletDWTSubbandLength(num_rows, scale, 0, 0, 0);
      baseband_num_cols =
        QccWAVWaveletDWTSubbandLength(num_cols, scale, 0, 0, 0);
      
      for (col = 0; col < baseband_num_cols; col++)
        {
          for (row = 0; row < baseband_num_rows; row++)
            {
              input_data_vector[row] = output_data[row][col];
              input_mask_vector[row] = output_mask[row][col];
            }
          
          if (QccWAVWaveletShapeAdaptiveSynthesis1D(input_data_vector,
                                                    output_data_vector,
                                                    subsequence,
                                                    input_mask_vector,
                                                    output_mask_vector,
                                                    baseband_num_rows,
                                                    wavelet))
            {
              QccErrorAddMessage("(QccWAVWaveletInverseShapeAdaptiveDWT2D): Error calling QccWAVWaveletShapeAdaptiveSynthesis1D()");
              goto Error;
            }
          
          for (row = 0; row < baseband_num_rows; row++)
            {
              output_data[row][col] = output_data_vector[row];
              output_mask[row][col] = output_mask_vector[row];
            }
        }