ITAOps.h 6.26 KB
Newer Older
1 2 3 4 5
/*
* ----------------------------------------------------------------
*
*		ITA core libs
*		(c) Copyright Institute of Technical Acoustics (ITA)
6
*		RWTH Aachen University, Germany, 2015-2017
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
*
* ----------------------------------------------------------------
*				    ____  __________  _______
*				   //  / //__   ___/ //  _   |
*				  //  /    //  /    //  /_|  |
*				 //  /    //  /    //  ___   |
*				//__/    //__/    //__/   |__|
*
* ----------------------------------------------------------------
*
*/

#ifndef INCLUDE_WATCHER_ITA_OPS
#define INCLUDE_WATCHER_ITA_OPS

//--------------------------------------------------------------------------------------
// includes
//--------------------------------------------------------------------------------------

#include <ITABaseDefinitions.h>

#include <string>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <list>
#include <map>

//--------------------------------------------------------------------------------------

float ITA_BASE_API roundIt(const float Zahl, const int Stellen);
//--------------------------------------------------------------------------------------
// define
//--------------------------------------------------------------------------------------

void ITA_BASE_API getUniqueIDsFromList(
	const std::vector<unsigned int>	&inputList,
	std::list<unsigned int>		&outputList);

void ITA_BASE_API getUniqueIDsFromList(
	unsigned int*				&inputList,
	const int					&inputListLength,
	std::list<unsigned int>		&outputList);

void ITA_BASE_API getUniqueIDsFromList(
	const std::list<unsigned int> &inputList,
	std::list<unsigned int>	&outputList);

unsigned int ITA_BASE_API getID_BinaryToInteger(
	const std::list<unsigned int> &inputList);

void ITA_BASE_API getID_BinaryToInteger(
	const std::list<unsigned int> &inputList,
	const unsigned int			&roomCombinationListID);

void ITA_BASE_API storeCurrentSubPowerSet(
	const std::list<unsigned int>	&my_power_set,	// IN
	std::list<unsigned int>	&valid_power_set_ids);	// OUT

void ITA_BASE_API buildSubPowerSets(
	unsigned int			&counter,
	unsigned int			startIndex,
	const std::list<unsigned int>	&my_power_set,
	std::list<unsigned int>	&my_helper,
	std::list<unsigned int>	&valid_power_set_ids);

void ITA_BASE_API buildSubPowerSets(
	const std::list<unsigned int>	&my_power_set,
	std::list<unsigned int>	&valid_power_set_ids );


// --= Interpolationsroutinen =--

//! Einfache lineare Interpolation zwischen zwei Vektoren
void ITA_BASE_API interpolate(
	std::vector<float> &result,
	const std::vector<float> &a,
	const std::vector<float> &b);

//! Interpolationroutine
/**
 * \param x				Ergebnis der Interpolation
 * \param y				Zu interpolierende Daten
 * \param xDomainScale	Skala des gewünschten Ergebnisses (gleiche Grösse wie x)
 * \param yDomainScale	Skala der Eingabedaten (gleiche Grösse wie y)
 * \param IntType		Gewünschte Interpolationsart: 0 für Halteglied, 1 für lineare Interpolation, 2 für Spline-Interpolation
 */
void ITA_BASE_API Interpolation(
	std::vector<float> &x,
	const std::vector<float> &y, 
	const std::vector<float> &xDomainScale, 
	const std::vector<float> &yDomainScale, 
	const unsigned int IntType);


// --= Insert-Routinen =--

//! Fügt das Einzelfilter in das Gesamtfilter ein (Float-Vector zu Float-Vector Implementierung)
void ITA_BASE_API Insert(
	const std::vector<float> &pfSource,
	std::vector<float> &pfDest,
	const float fOffset,
	const unsigned int uiLength);

//! Fügt das Einzelfilter in das Gesamtfilter ein (Float-Feld zu Float-Vector Implementierung)
void ITA_BASE_API Insert(
	const float *pfSource,
	std::vector<float> &pfDest,
	const float fOffset,
	const unsigned int uiLength);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
void ITA_BASE_API Insert_scaled(
	const std::vector<float> &pfSource, 
	std::vector<float> &pfDest, 
	const float iDestinationOffset, 
	const unsigned int uiLength,
	const float fScaleFactor);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
127
void ITA_BASE_API Insert_scaled(
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	const std::vector<float> &pfSource, 
	std::vector<float> &pfDest, 
	const unsigned int uiDestinationOffset, 
	const unsigned int uiLength,
	const float scaleFactor);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
void ITA_BASE_API Insert_scaled(
	const float* pfSource, 
	std::vector<float> &pfDest, 
	const unsigned int uiDestinationOffset, 
	const unsigned int uiLength,
	const float fScaleFactor);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
void ITA_BASE_API Insert_scaled(
	const float* pfSource, 
	float* pfDest, 
	const unsigned int uiDestinationOffset, 	
	const unsigned int uiNumSamples,
	const float fScaleFactor);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
void ITA_BASE_API Insert_scaled(
	const std::vector<float> &pfSource, 
	std::vector<float> &pfDest, 
	const unsigned int iInsertPosition,
	const float fScaleFactor);

//! Fügt das Einzelfilter in das Gesamtfilter mit Skalierung ein
void ITA_BASE_API Insert_scaled(
	const float* pfSource, 
	float* pfDest, 
	const int iDestinationOffset, 
	const int iNumSamples, 
	const float fScaleFactor );

//! cartesian2polar - converts a complex number from real/imaginary to magnitude/phase representation
void ITA_BASE_API cartesian2polar(
	float	real,
	float	imaginary,
	float&	magnitude,
	float&	phase);

//! polar2cartesian - converts a complex number from magnitude/phase to real/imaginary representation
void ITA_BASE_API polar2cartesian(
	float	magnitude,
	float	phase,
	float&	real,
	float&	imaginary);

int ITA_BASE_API readPortalParameter(
	const std::string filename_fullPath,
	std::vector<float>& transfer_function,
	std::string &portal_name,
	std::string &portal_notes,
	std::string & portal_surface_material);

/**
*determineCurrentValidPowerSetIDs
*
**/
void ITA_BASE_API determineCurrentValidPowerSetIDs(
	const std::list<unsigned int>	&currentValidRoomIDs,
	std::list<unsigned int>			&currentValidPowerSetIDs);

//! Schreibt den Inhalt eines std::vector mit Float-Werten in den RavenOutput (zu Debugging-zwecken)
/**
  * \param vfVec Der Vektor, der runtergeschrieben werden soll
  * \param sName Dateiname
  *
  * \note Exportiert die Daten in den Ordner "..\RavenOutput" (muss existieren!)
  */
void ITA_BASE_API writeVector( const std::vector<float> vfVec, std::string sName );

#endif // INCLUDE_WATCHER_ITA_OPS