src/tier2/segmentData.cc

/*
    MPEG Maaate: An Australian MPEG audio analysis toolkit
    Copyright (C) 2000 Commonwealth Scientific and Industrial Research Organisation
    (CSIRO), Australia.

    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 should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

//#include <curses.h> //for getchar()
#include <cfloat>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include "segmentData.H"

// constructor
CSAPI_TIER2
SegmentData::SegmentData(double t1, double t2, int col, int row,
			 int i, char f, double cnf) :
    starttime(t1), endtime(t2), columns(col), rows(row),
    id(i), flag(f), conf(cnf) {
	if (col<0) col=0;
	if (row<0) row=0;
	if (col>0 || row>0) {
	    data = new double*[col];
	    if (!data) {
		cerr << "MaaateA: SegmentData: No space available" << endl;
		exit(1);
	    }
	    for (int i=0; i<col; i++) {
			data[i] = new double[row];
			if (!data[i]) {
				cerr << "MaaateA: SegmentData: No space available" << endl;
				exit(1);
			}
			memset(data[i],0,sizeof(double)*row);
	    }
	} else {
	    data = NULL;
	}

	// initialize summarizing values
	clear_all();
	colFilled = 0;
}

// destructor
CSAPI_TIER2
SegmentData::~SegmentData() {
    for (int i=0; i<columns; i++)
	delete[] data[i];
    delete[] data;
}

// copy constructor
CSAPI_TIER2
SegmentData::SegmentData(const SegmentData& sd) {
    starttime = sd.starttime;
    endtime   = sd.endtime;
    columns   = sd.columns;
    rows      = sd.rows;
    id        = sd.id;
    flag      = sd.flag;
    conf      = sd.conf;
    // no previously stored data: just allocate storage
    data      = new double*[columns];
    for (int i=0; i<columns; i++) {
	data[i] = new double[rows];
	for (int j=0; j<rows; j++) {
	    data[i][j] = sd.data[i][j];
	}
    }

    // initialize summarizing values
    clear_all();
    colFilled = sd.colFilled;
}


// partial copy constructor
CSAPI_TIER2
SegmentData::SegmentData(const SegmentData& sd,
			 int st_row, int end_row,
			 int i, char f, double cnf)
{
  int nb_rows;

/* row check */
  if ( st_row > end_row ) end_row = st_row;
  if ( st_row >= sd.rows ) st_row = sd.rows-1;
  if ( end_row >= sd.rows ) end_row = sd.rows-1;

  nb_rows = end_row - st_row + 1;

  starttime = sd.starttime;
  endtime   = sd.endtime;
  columns   = sd.columns;
  rows      = nb_rows;
  id        = i;
  flag      = f;
  conf      = cnf;

  // no previously stored data: just allocate storage
  data      = new double*[columns];
  for (int j=0; j<columns; j++) {
    data[j] = new double[nb_rows];
    for (int k=0; k<nb_rows; k++) {
      data[j][k] = sd.data[j][k+st_row];
    }
  }

    // initialize summarizing values
    clear_all();
    colFilled = sd.colFilled;
}

// overload =
CSAPI_TIER2 SegmentData&
SegmentData::operator=(const SegmentData& sd) {
    if (this == &sd)
	return *this;
    starttime = sd.starttime;
    endtime   = sd.endtime;
    columns   = sd.columns;
    rows      = sd.rows;
    id        = sd.id;
    flag      = sd.flag;
    conf      = sd.conf;
    // delete previously stored data
    if (data != NULL) {
	for (int i=0; i<columns; i++)
	    delete[] data[i];
	delete[] data;
    }
    data      = new double*[columns];
    for (int i=0; i<columns; i++) {
	data[i] = new double[rows];
	for (int j=0; j<rows; j++) {
	    data[i][j] = sd.data[i][j];
	}
    }

    // initialize summarizing values
    clear_all();
    colFilled = sd.colFilled;

    return *this;
}


// overload friend operator <<
// main usage: debugging
CSAPI_TIER2 ostream&
operator<<(ostream& os, const SegmentData& sd) {
    // print all contained data
    cout << "Start: " << sd.start() << endl;
    cout << "End: "   << sd.end() << endl;
    cout << "ID=" << sd.ident() << "\tflag=" << sd.uflag() << endl;
    cout << "Confidence=" << sd.confidence() << endl;
    cout << "Columns=" << sd.no_columns() << "\tRows=" << sd.no_rows() << endl;
    cout << "Filled until column: " << sd.col_filled() << endl;
//    os << "Start: " << sd.start() << endl;
//    os << "End: "   << sd.end() << endl;
//    os << "ID=" << sd.ident() << "\tflag=" << sd.uflag() << endl;
//    os << "Confidence=" << sd.confidence() << endl;
//    os << "Columns=" << sd.no_columns() << "\tRows=" << sd.no_rows() << endl;
//    os << "Filled until column: " << sd.col_filled() << endl;
    for (int i=0; i<sd.col_filled(); i++) {
	cout << i << ":\t";
//	os << i << ":\t";
	for (int j=0; j<sd.no_rows(); j++) {
	    cout << sd.data[i][j] << " ";
//	    os << sd.data[i][j] << " ";
	}
	os << endl;
    }
    os << "--- END OF ENTRY ---" << endl;
    return os;
}


// convert from a time to a colum number
CSAPI_TIER2 int
SegmentData::time2col(double time) const {
  // assert that the time is between starttime and endtime
  if (time <= starttime) return 0;
  if (time >= endtime) return columns;
  return (int) ((time - starttime)/resolution());
}


// sum a part of contained data
CSAPI_TIER2 double
SegmentData::sum(int start, int end, int startrow, int endrow) {
  if (start < 0) start = 0;
  if (end < 0) end = 0;
  if (start >= colFilled) start = colFilled - 1;
  if (end >= colFilled) end = colFilled - 1;
  if (startrow < 0) startrow = 0;
  if (endrow < 0)   endrow = 0;
  if (startrow >= rows) startrow = rows-1;
  if (endrow >= rows)   endrow = rows-1;

  double sum = 0.0;

  for (int i=start; i<=end; i++) {
    for (int j=startrow; j<=endrow; j++) {
      sum += data[i][j];
    }
  }
  return sum;
}


// minimum of contained data within start and end times
CSAPI_TIER2 double
SegmentData::smin(double start, double end, int startrow, int endrow) {
  double minimum = DBL_MAX;
  if (start < starttime) start = starttime;
  if (end > endtime) end = endtime;
  if (startrow < 0) startrow = 0;
  if (endrow < 0)   endrow = 0;
  if (startrow >= rows) startrow = rows-1;
  if (endrow >= rows)   endrow = rows-1;

  // check whether min of all data is requested
  if (start == starttime && end == endtime &&
      startrow == 0 && endrow == rows-1) {
    return smin();
  }

  int startcol = time2col(start);
  int endcol   = time2col(end);
  if (colFilled < endcol) endcol = colFilled;

  for (int i=startcol; i<endcol; i++) {
    for (int j=startrow; j<=endrow; j++) {
      if (data[i][j] < minimum) minimum = data[i][j];
    }
  }
  return minimum;
}

// maximum of contained data within start and end times
CSAPI_TIER2 double
SegmentData::smax(double start, double end, int startrow, int endrow) {
  double maximum = DBL_MIN;
  if (start < starttime) start = starttime;
  if (end > endtime) end = endtime;
  if (startrow < 0) startrow = 0;
  if (endrow < 0)   endrow = 0;
  if (startrow >= rows) startrow = rows-1;
  if (endrow >= rows)   endrow = rows-1;

  // check whether max of all data is requested
  if (start == starttime && end == endtime &&
      startrow == 0 && endrow == rows-1) {
    return smax();
  }

  int startcol = time2col(start);
  int endcol   = time2col(end);
  if (colFilled < endcol) endcol = colFilled;

  for (int i=startcol; i<endcol; i++) {
    for (int j=startrow; j<=endrow; j++) {
      if (data[i][j] > maximum) maximum = data[i][j];
    }
  }
  return maximum;
}

// mean of data within a part of the data
CSAPI_TIER2 double
SegmentData::avg(int start, int end, int startrow, int endrow) {
  if (start < 0) start = 0;
  if (end < 0) end = 0;
  if (start >= colFilled) start = colFilled - 1;
  if (end >= colFilled) end = colFilled - 1;
  if (startrow < 0) startrow = 0;
  if (endrow < 0)   endrow = 0;
  if (startrow >= rows) startrow = rows-1;
  if (endrow >= rows)   endrow = rows-1;

  int nb = (end - start + 1) * (endrow - startrow + 1);

  return (sum(start, end, startrow, endrow)/nb);
}


/*--------------------- Tools  for Normalisations --------------------*/

// sum of all contained data
CSAPI_TIER2 double
SegmentData::sum() {
    if (sum_save!=0.0) {
	return sum_save;
    }

    // if not yet calculated, do that now
    for (int i=0; i<colFilled; i++) {
	for (int j=0; j<rows; j++) {
	    sum_save += data[i][j];
	}
    }
    return sum_save;
}


// minimum of all contained data
CSAPI_TIER2 double
SegmentData::smin(double downto) {

  double * ptr;

  if (min_save!=DBL_MAX) {
    return min_save;
  }

  // if not yet calculated, do that now
  for (int i=0; i<colFilled; i++) {
    for (int j=0; j<rows; j++) {
      ptr = &(data[i][j]);
      if ((*ptr) < min_save && (*ptr) >= downto ) {
	min_save = (*ptr);
      }
    }
  }
  return min_save;
}


// maximum of all contained data
CSAPI_TIER2 double
SegmentData::smax(double upto) {

  double * ptr;

  if (max_save!=-DBL_MAX) {
    return max_save;
  }

  // if not yet calculated, do that now
  for (int i=0; i<colFilled; i++) {
    for (int j=0; j<rows; j++) {
      ptr = &(data[i][j]);
      if ((*ptr) > max_save && (*ptr) <= upto ) {
	max_save = (*ptr);
      }
    }
  }
  return max_save;
}


// mean of all contained data
CSAPI_TIER2 double
SegmentData::avg() {
    return (sum()/(colFilled*rows));
}

/*--------------------- Normalisation --------------------*/

// normalize data values to [0;1], clipping outside of [downto;upto]
CSAPI_TIER2 bool
SegmentData::normalise(double downto, double upto) {

  double * ptr;

  //initialising summarised values
  clear_all();

  // calculate factor for normalisation
  double factor;
  factor = smax(upto) - smin(downto);

  // check if normalisation possible
  if (factor <= 0.0) {
    return false;
  }

  // perform normalisation
  for (int i=0; i<colFilled; i++) {
    for (int j=0; j<rows; j++) {
      //pointer to the value to normalise
      ptr = &(data[i][j]);
      if ((*ptr) < downto) {
	//clipping min
	(*ptr) = 0.0;
      } else if ((*ptr) > upto) {
	//clipping max
	(*ptr) = 1.0;
      } else {
	(*ptr) = ((*ptr) - min_save) / factor;
      }
    }
  }

  // initialize summarizing values
  clear_all();

  return true;
}


/*--------------------- Smoothing --------------------*/

// smoothes the data in time with a mean filter of the order order

CSAPI_TIER2 bool
SegmentData::smooth(int start, int end, int startrow, int endrow, int order)
{

  // cheching of input
  if (start < 0) start = 0;
  if (end < 0) end = 0;
  if (start >= colFilled) start = colFilled - 1;
  if (end >= colFilled) end = colFilled - 1;
  if (startrow < 0) startrow = 0;
  if (endrow < 0)   endrow = 0;
  if (startrow >= rows) startrow = rows-1;
  if (endrow >= rows)   endrow = rows-1;
  if (order%2==0)
  {
    cerr << "order should be odd, it is now set to an odd value by adding 1" <<endl;
    order += 1;
  }


  int bufferSize = colFilled;
  int orderHalf;
  double mean;
  int i, n, j; //index variables
  double *oldValues;

  // initialisation
  orderHalf = (int)(order/2);
  oldValues = new double[orderHalf+1];

  for (i=startrow; i<=endrow; i++)       //loop over rows
  {

    memset (oldValues,0,(orderHalf+1)*sizeof(double));
    mean = 0;

    //calculation of first mean
    for (n=0; n<=orderHalf; n++)
      mean += data[n][i];
    mean = mean / (orderHalf + 1);
    oldValues[0] = data[0][i];
    data[0][i] = mean;

    //loop to calculate mean in the range of order for first values
    for (n=1; n<(orderHalf+1); n++)
    {
      mean = (mean*(orderHalf+n) + data[n+orderHalf][i])/(orderHalf+n+1);
      oldValues[n] = data[n][i];
      data[n][i] = mean;
    }

    //loop for middle value
    for (n=(orderHalf+1); n<(bufferSize-orderHalf); n++)
    {
      mean = (mean*order - oldValues[n%(orderHalf+1)] + data[n+orderHalf][i])/order;
      oldValues[n%(orderHalf+1)] = data[n][i];
      data[n][i] = mean;
    }

    //loop for last values
    j = 0;
    for (n=(bufferSize-orderHalf); n<bufferSize; n++)
    {
      mean = (mean*(order-j) - oldValues[n%(orderHalf+1)])/(order-j-1);
      data[n][i] = mean;
      j++;
    }
  }                                      //end loop over rows

  delete[] oldValues;

  return true;

}

/*--------------------- MATLAB output --------------------*/

// saves the data in the MATLAB binary *.mat format

// view with plot(varName) for 1-dimensional curves (i.e. sscf)
// or imagesc(varName) for 2-dimensional data(i.e. sbmean)

CSAPI_TIER2 bool
SegmentData::matOut(char* fileName)
{

	struct matHeader
	{
		signed int adf [4];		// Array data format fields
	};


	FILE *fd = 0;				// File handler
	struct matHeader hdr;		// Header for MATLAB file
	struct matHeader varHdr;	// Header for additional Variables
	char arrayName [64];		// MATLAB name of array
	signed int nameLength = 0;	// Number of bytes of arrayName in header
	char varName [64];			// Name of additional Variables
	signed int varNameLength = 0;
	double sample = 0;

	char matFileName [128];		// Name of output file, with or without path

	unsigned long i, j, k;		// Index variable

    strncpy(matFileName, fileName, 128);
	if ( strstr(matFileName, ".mat") == NULL)
		strcat(matFileName, ".mat");

	// Open mat-file
	fd = fopen (matFileName, "w+b");

	if (!fd)
	{
		cerr << "Can't create MAT file " << matFileName <<endl;
		cerr << "Filename default.mat is used instead" <<endl;
		strncpy("default.mat", matFileName, 128);
		for (i=11;i<128;i++) matFileName[i] = ' ';
		fd = fopen (matFileName, "w+b");
	}

	// Header Field for Array Dimensions
	hdr.adf[0] = (signed int) 0;
	hdr.adf[1] = (signed int) rows;		// This is the number of rows
	hdr.adf[2] = (signed int) columns;  // This is the number of columns
	hdr.adf[3] = (signed int) 0;

	// Array Name
	// We'll use matFileName for the matlab array name (as well as the file name).
	// If fileName is 4 characters or less, empty space will be added
	nameLength = (signed int)strlen(matFileName);
	if (strstr(matFileName,".mat"))
		nameLength -=4;
	if (nameLength > 31)
		nameLength = 31;				// Truncate name to 31 characters
	strncpy (arrayName, matFileName, nameLength);

	if (nameLength < 4)					// Addition of empty space
	{
		for (i=nameLength; i<4; i++)
		{
			arrayName[i] = 0;
			nameLength++;
		}
	}
	arrayName [nameLength++] = '\0';

	// Write the header
	if (fwrite (&hdr, 16, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write MATLAB array name
	if (fwrite (&nameLength, 4, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}
	if (fwrite (arrayName, nameLength, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	cout << "Creating MAT-file containing MATLAB array " << arrayName <<endl;

	// Write data
	for (k=0; k<colFilled; k++)
	{
		for (j=0; j<rows; j++)
		{
			sample = data[k][j];
			if (fwrite (&sample, 8, 1, fd) != 1)
			{
				cerr << "Error writing to file " << matFileName <<endl;
				return false;
			}
		}

	}

	// Write Resolution in mat-file

	// Header Field for Resolution
	varHdr.adf[0] = (signed int) 0;
	varHdr.adf[1] = (signed int) 1;		// This is the number of rows
	varHdr.adf[2] = (signed int) 1;		// This is the number of columns
	varHdr.adf[3] = (signed int) 0;

	char tmp1 [64] = "resolution";
	varNameLength = 10;
	strncpy (varName, tmp1, varNameLength);
	varName [varNameLength++] = 0;

	// Write the header
	if (fwrite (&varHdr, 16, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable name
	if (fwrite (&varNameLength, 4, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}
	if (fwrite (varName, varNameLength, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable Value
	sample = resolution();
	if (fwrite (&sample, 8, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Resolution in mat-file

	// Header Field for Resolution
	varHdr.adf[0] = (signed int) 0;
	varHdr.adf[1] = (signed int) 1;		// This is the number of rows
	varHdr.adf[2] = (signed int) 1;		// This is the number of columns
	varHdr.adf[3] = (signed int) 0;

	char tmp2 [64] = "startTime";
	varNameLength = 9;
	strncpy (varName, tmp2, varNameLength);
	varName [varNameLength++] = 0;

	// Write the header
	if (fwrite (&varHdr, 16, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable name
	if (fwrite (&varNameLength, 4, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}
	if (fwrite (varName, varNameLength, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable Value
	sample = starttime;
	if (fwrite (&sample, 8, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write EndTime in mat-file

	// Header Field for Resolution
	varHdr.adf[0] = (signed int) 0;
	varHdr.adf[1] = (signed int) 1;		// This is the number of rows
	varHdr.adf[2] = (signed int) 1;		// This is the number of columns
	varHdr.adf[3] = (signed int) 0;

	char tmp3 [64] = "endTime";
	varNameLength = 7;
	strncpy (varName, tmp3, varNameLength);
	varName [varNameLength++] = 0;

	// Write the header
	if (fwrite (&varHdr, 16, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable name
	if (fwrite (&varNameLength, 4, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}
	if (fwrite (varName, varNameLength, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	// Write Variable Value
	sample = endtime;
	if (fwrite (&sample, 8, 1, fd) != 1)
	{
		cerr << "Error writing to file " << matFileName <<endl;
		return false;
	}

	fclose (fd);

  return true;

}

/*------------------- Initialisation ------------------*/

CSAPI_TIER2 void
SegmentData::initData (double val) {
  // initialize data values to val
  for (int i=0; i<columns; i++) {
    for (int j=0; j<rows; j++) {
      data[i][j] = val;
    }
  }

  return;
}