From af50ae73cfe6f1533e5390e5131e25c6d322dc8a Mon Sep 17 00:00:00 2001
From: cam <cameron@ideum.com>
Date: Wed, 4 Jan 2017 23:09:30 -0700
Subject: removed .cpp and .h files

---
 video_input/consistencyChecker/CVector.h | 519 -------------------------------
 1 file changed, 519 deletions(-)
 delete mode 100644 video_input/consistencyChecker/CVector.h

(limited to 'video_input/consistencyChecker/CVector.h')

diff --git a/video_input/consistencyChecker/CVector.h b/video_input/consistencyChecker/CVector.h
deleted file mode 100644
index aacb0fa..0000000
--- a/video_input/consistencyChecker/CVector.h
+++ /dev/null
@@ -1,519 +0,0 @@
-// CVector
-// A one-dimensional array including basic vector operations
-//
-// Author: Thomas Brox
-// Last change: 23.05.2005
-//-------------------------------------------------------------------------
-#ifndef CVECTOR_H
-#define CVECTOR_H
-
-#include <iostream>
-#include <fstream>
-
-template <class T> class CMatrix;
-template <class T> class CTensor;
-
-template <class T>
-class CVector {
-public:
-  // constructor
-  inline CVector();
-  // constructor
-  inline CVector(const int aSize);
-  // copy constructor
-  CVector(const CVector<T>& aCopyFrom);
-  // constructor (from array)
-  CVector(const T* aPointer, const int aSize);
-  // constructor with implicit filling
-  CVector(const int aSize, const T aFillValue);
-  // destructor
-  virtual ~CVector();
-
-  // Changes the size of the vector (data is lost)
-  void setSize(int aSize);
-  // Fills the vector with the specified value (see also operator=)
-  void fill(const T aValue);
-  // Appends the values of another vector
-  void append(CVector<T>& aVector);
-  // Normalizes the length of the vector to 1
-  void normalize();
-  // Normalizes the component sum to 1
-  void normalizeSum();
-  // Reads values from a text file
-  void readFromTXT(const char* aFilename);
-  // Writes values to a text file
-  void writeToTXT(char* aFilename);
-  // Returns the sum of all values
-  T sum();
-  // Returns the minimum value
-  T min();
-  // Returns the maximum value
-  T max();
-  // Returns the Euclidean norm
-  T norm();
-
-  // Converts vector to homogeneous coordinates, i.e., all components are divided by last component
-  CVector<T>& homogen();
-  // Remove the last component
-  inline void homogen_nD();
-  // Computes the cross product between this vector and aVector
-  void cross(CVector<T>& aVector);
-
-  // Gives full access to the vector's values
-  inline T& operator()(const int aIndex) const;
-  inline T& operator[](const int aIndex) const;
-  // Fills the vector with the specified value (equivalent to fill)
-  inline CVector<T>& operator=(const T aValue);
-  // Copies a vector into this vector (size might change)
-  CVector<T>& operator=(const CVector<T>& aCopyFrom);
-  // Copies values from a matrix to the vector (size might change)
-  CVector<T>& operator=(const CMatrix<T>& aCopyFrom);
-  // Copies values from a tensor to the vector (size might change)
-  CVector<T>& operator=(const CTensor<T>& aCopyFrom);
-  // Adds another vector
-  CVector<T>& operator+=(const CVector<T>& aVector);
-  // Substracts another vector
-  CVector<T>& operator-=(const CVector<T>& aVector);
-  // Multiplies the vector with a scalar
-  CVector<T>& operator*=(const T aValue);
-  // Scalar product
-  T operator*=(const CVector<T>& aVector);
-  // Checks (non-)equivalence to another vector
-  bool operator==(const CVector<T>& aVector);
-  inline bool operator!=(const CVector<T>& aVector);
-
-  // Gives access to the vector's size
-  inline int size() const;
-  // Gives access to the internal data representation
-  inline T* data() const {return mData;}
-protected:
-  int mSize;
-  T* mData;
-};
-
-// Adds two vectors
-template <class T> CVector<T> operator+(const CVector<T>& vec1, const CVector<T>& vec2);
-// Substracts two vectors
-template <class T> CVector<T> operator-(const CVector<T>& vec1, const CVector<T>& vec2);
-// Multiplies vector with a scalar
-template <class T> CVector<T> operator*(const CVector<T>& aVector, const T aValue);
-template <class T> CVector<T> operator*(const T aValue, const CVector<T>& aVector);
-// Computes the scalar product of two vectors
-template <class T> T operator*(const CVector<T>& vec1, const CVector<T>& vec2);
-// Computes cross product of two vectors
-template <class T> CVector<T> operator/(const CVector<T>& vec1, const CVector<T>& vec2);
-// Sends the vector to an output stream
-template <class T> std::ostream& operator<<(std::ostream& aStream, const CVector<T>& aVector);
-
-// Exceptions thrown by CVector--------------------------------------------
-
-// Thrown if one tries to access an element of a vector which is out of
-// the vector's bounds
-struct EVectorRangeOverflow {
-  EVectorRangeOverflow(const int aIndex) {
-    using namespace std;
-    cerr << "Exception EVectorRangeOverflow: Index = " << aIndex << endl;
-  }
-};
-
-struct EVectorIncompatibleSize {
-  EVectorIncompatibleSize(int aSize1, int aSize2) {
-    using namespace std;
-    cerr << "Exception EVectorIncompatibleSize: " << aSize1 << " <> " << aSize2 << endl;
-  }
-};
-
-
-// I M P L E M E N T A T I O N --------------------------------------------
-//
-// You might wonder why there is implementation code in a header file.
-// The reason is that not all C++ compilers yet manage separate compilation
-// of templates. Inline functions cannot be compiled separately anyway.
-// So in this case the whole implementation code is added to the header
-// file.
-// Users of CVector should ignore everything that's beyond this line.
-// ------------------------------------------------------------------------
-
-// P U B L I C ------------------------------------------------------------
-// constructor
-template <class T>
-inline CVector<T>::CVector() : mSize(0) {
-  mData = new T[0];
-}
-
-// constructor
-template <class T>
-inline CVector<T>::CVector(const int aSize)
-  : mSize(aSize) {
-  mData = new T[aSize];
-}
-
-// copy constructor
-template <class T>
-CVector<T>::CVector(const CVector<T>& aCopyFrom)
-  : mSize(aCopyFrom.mSize) {
-  mData = new T[mSize];
-  for (int i = 0; i < mSize; i++)
-    mData[i] = aCopyFrom.mData[i];
-}
-
-// constructor (from array)
-template <class T>
-CVector<T>::CVector(const T* aPointer, const int aSize)
-  : mSize(aSize) {
-  mData = new T[mSize];
-  for (int i = 0; i < mSize; i++)
-    mData[i] = aPointer[i];
-}
-
-// constructor with implicit filling
-template <class T>
-CVector<T>::CVector(const int aSize, const T aFillValue)
-  : mSize(aSize) {
-  mData = new T[aSize];
-  fill(aFillValue);
-}
-
-// destructor
-template <class T>
-CVector<T>::~CVector() {
-  delete[] mData;
-}
-
-// setSize
-template <class T>
-void CVector<T>::setSize(int aSize) {
-  if (mData != 0) delete[] mData;
-  mData = new T[aSize];
-  mSize = aSize;
-}
-
-// fill
-template <class T>
-void CVector<T>::fill(const T aValue) {
-  for (register int i = 0; i < mSize; i++)
-    mData[i] = aValue;
-}
-
-// append
-template <class T>
-void CVector<T>::append(CVector<T>& aVector) {
-  T* aNewData = new T[mSize+aVector.size()];
-  for (int i = 0; i < mSize; i++)
-    aNewData[i] = mData[i];
-  for (int i = 0; i < aVector.size(); i++)
-    aNewData[i+mSize] = aVector(i);
-  mSize += aVector.size();
-  delete[] mData;
-  mData = aNewData;
-}
-
-// normalize
-template <class T>
-void CVector<T>::normalize() {
-  T aSum = 0;
-  for (register int i = 0; i < mSize; i++)
-    aSum += mData[i]*mData[i];
-  if (aSum == 0) return;
-  aSum = 1.0/sqrt(aSum);
-  for (register int i = 0; i < mSize; i++)
-    mData[i] *= aSum;
-}
-
-// normalizeSum
-template <class T>
-void CVector<T>::normalizeSum() {
-  T aSum = 0;
-  for (register int i = 0; i < mSize; i++)
-    aSum += mData[i];
-  if (aSum == 0) return;
-  aSum = 1.0/aSum;
-  for (register int i = 0; i < mSize; i++)
-    mData[i] *= aSum;
-}
-
-// readFromTXT
-template<class T>
-void CVector<T>::readFromTXT(const char* aFilename) {
-  std::ifstream aStream(aFilename);
-  mSize = 0;
-  float aDummy;
-  while (!aStream.eof()) {
-    aStream >> aDummy;
-    mSize++;
-  }
-  aStream.close();
-  std::ifstream aStream2(aFilename);
-  delete mData;
-  mData = new T[mSize];
-  for (int i = 0; i < mSize; i++)
-    aStream2 >> mData[i];
-}
-
-// writeToTXT
-template<class T>
-void CVector<T>::writeToTXT(char* aFilename) {
-  std::ofstream aStream(aFilename);
-  for (int i = 0; i < mSize; i++)
-    aStream << mData[i] << std::endl;
-}
-
-// sum
-template <class T>
-T CVector<T>::sum() {
-  T val = mData[0];
-  for (int i = 1; i < mSize; i++)
-    val += mData[i];
-  return val;
-}
-
-// min
-template <class T>
-T CVector<T>::min() {
-  T bestValue = mData[0];
-  for (int i = 1; i < mSize; i++)
-    if (mData[i] < bestValue) bestValue = mData[i];
-  return bestValue;
-}
-
-// max
-template <class T>
-T CVector<T>::max() {
-  T bestValue = mData[0];
-  for (int i = 1; i < mSize; i++)
-    if (mData[i] > bestValue) bestValue = mData[i];
-  return bestValue;
-}
-
-// norm
-template <class T>
-T CVector<T>::norm() {
-  T aSum = 0.0;
-  for (int i = 0; i < mSize; i++)
-    aSum += mData[i]*mData[i];
-  return sqrt(aSum);
-}
-
-// homogen
-template <class T>
-CVector<T>& CVector<T>::homogen() {
-  if (mSize > 1 && mData[mSize-1] != 0) {
-    T invVal = 1.0/mData[mSize-1];
-  	for (int i = 0; i < mSize; i++)
-      mData[i] *= invVal;
-  }
-  return (*this);
-}
-
-// homogen_nD
-template <class T>
-inline void CVector<T>::homogen_nD() {
-  mSize--;
-}
-
-// cross
-template <class T>
-void CVector<T>::cross(CVector<T>& aVector) {
-  T aHelp0 = aVector(2)*mData[1] - aVector(1)*mData[2];
-  T aHelp1 = aVector(0)*mData[2] - aVector(2)*mData[0];
-  T aHelp2 = aVector(1)*mData[0] - aVector(0)*mData[1];
-  mData[0] = aHelp0;
-  mData[1] = aHelp1;
-  mData[2] = aHelp2;
-}
-
-// operator()
-template <class T>
-inline T& CVector<T>::operator()(const int aIndex) const {
-  #ifdef _DEBUG
-    if (aIndex >= mSize || aIndex < 0)
-      throw EVectorRangeOverflow(aIndex);
-  #endif
-  return mData[aIndex];
-}
-
-// operator[]
-template <class T>
-inline T& CVector<T>::operator[](const int aIndex) const {
-  return operator()(aIndex);
-}
-
-// operator=
-template <class T>
-inline CVector<T>& CVector<T>::operator=(const T aValue) {
-  fill(aValue);
-  return *this;
-}
-
-template <class T>
-CVector<T>& CVector<T>::operator=(const CVector<T>& aCopyFrom) {
-  if (this != &aCopyFrom) {
-    if (mSize != aCopyFrom.size()) {
-      delete[] mData;
-      mSize = aCopyFrom.size();
-      mData = new T[mSize];
-    }
-    for (register int i = 0; i < mSize; i++)
-      mData[i] = aCopyFrom.mData[i];
-  }
-  return *this;
-}
-
-template <class T>
-CVector<T>& CVector<T>::operator=(const CMatrix<T>& aCopyFrom) {
-  if (mSize != aCopyFrom.size()) {
-    delete[] mData;
-    mSize = aCopyFrom.size();
-    mData = new T[mSize];
-  }
-  for (register int i = 0; i < mSize; i++)
-    mData[i] = aCopyFrom.data()[i];
-  return *this;
-}
-
-template <class T>
-CVector<T>& CVector<T>::operator=(const CTensor<T>& aCopyFrom) {
-  if (mSize != aCopyFrom.size()) {
-    delete[] mData;
-    mSize = aCopyFrom.size();
-    mData = new T[mSize];
-  }
-  for (register int i = 0; i < mSize; i++)
-    mData[i] = aCopyFrom.data()[i];
-  return *this;
-}
-
-// operator +=
-template <class T>
-CVector<T>& CVector<T>::operator+=(const CVector<T>& aVector) {
-  #ifdef _DEBUG
-  if (mSize != aVector.size()) throw EVectorIncompatibleSize(mSize,aVector.size());
-  #endif
-  for (int i = 0; i < mSize; i++)
-    mData[i] += aVector(i);
-  return *this;
-}
-
-// operator -=
-template <class T>
-CVector<T>& CVector<T>::operator-=(const CVector<T>& aVector) {
-  #ifdef _DEBUG
-  if (mSize != aVector.size()) throw EVectorIncompatibleSize(mSize,aVector.size());
-  #endif
-  for (int i = 0; i < mSize; i++)
-    mData[i] -= aVector(i);
-  return *this;
-}
-
-// operator *=
-template <class T>
-CVector<T>& CVector<T>::operator*=(const T aValue) {
-  for (int i = 0; i < mSize; i++)
-    mData[i] *= aValue;
-  return *this;
-}
-
-template <class T>
-T CVector<T>::operator*=(const CVector<T>& aVector) {
-  #ifdef _DEBUG
-  if (mSize != aVector.size()) throw EVectorIncompatibleSize(mSize,aVector.size());
-  #endif
-  T aSum = 0.0;
-  for (int i = 0; i < mSize; i++)
-    aSum += mData[i]*aVector(i);
-  return aSum;
-}
-
-// operator ==
-template <class T>
-bool CVector<T>::operator==(const CVector<T>& aVector) {
-  if (mSize != aVector.size()) return false;
-  int i = 0;
-  while (i < mSize && aVector(i) == mData[i])
-    i++;
-  return (i == mSize);
-}
-
-// operator !=
-template <class T>
-inline bool CVector<T>::operator!=(const CVector<T>& aVector) {
-  return !((*this)==aVector);
-}
-
-// size
-template <class T>
-inline int CVector<T>::size() const {
-  return mSize;
-}
-
-// N O N - M E M B E R   F U N C T I O N S -------------------------------------
-
-// operator +
-template <class T>
-CVector<T> operator+(const CVector<T>& vec1, const CVector<T>& vec2) {
-  #ifdef _DEBUG
-  if (vec1.size() != vec2.size()) throw EVectorIncompatibleSize(vec1.size(),vec2.size());
-  #endif
-  CVector<T> result(vec1.size());
-  for (int i = 0; i < vec1.size(); i++)
-    result(i) = vec1[i]+vec2[i];
-  return result;
-}
-
-// operator -
-template <class T>
-CVector<T> operator-(const CVector<T>& vec1, const CVector<T>& vec2) {
-  #ifdef _DEBUG
-  if (vec1.size() != vec2.size()) throw EVectorIncompatibleSize(vec1.size(),vec2.size());
-  #endif
-  CVector<T> result(vec1.size());
-  for (int i = 0; i < vec1.size(); i++)
-    result(i) = vec1(i)-vec2(i);
-  return result;
-}
-
-// operator *
-template <class T>
-CVector<T> operator*(const T aValue, const CVector<T>& aVector) {
-  CVector<T> result(aVector.size());
-  for (int i = 0; i < aVector.size(); i++)
-    result(i) = aValue*aVector(i);
-  return result;
-}
-
-template <class T>
-CVector<T> operator*(const CVector<T>& aVector, const T aValue) {
-  return operator*(aValue,aVector);
-}
-
-template <class T>
-T operator*(const CVector<T>& vec1, const CVector<T>& vec2) {
-  #ifdef _DEBUG
-  if (vec1.size() != vec2.size()) throw EVectorIncompatibleSize(vec1.size(),vec2.size());
-  #endif
-  T aSum = 0.0;
-  for (int i = 0; i < vec1.size(); i++)
-    aSum += vec1(i)*vec2(i);
-  return aSum;
-}
-
-// operator /
-template <class T>
-CVector<T> operator/(const CVector<T>& vec1, const CVector<T>& vec2) {
-  CVector<T> result(3);
-  result[0]=vec1[1]*vec2[2] - vec1[2]*vec2[1];
-  result[1]=vec1[2]*vec2[0] - vec1[0]*vec2[2];
-  result[2]=vec1[0]*vec2[1] - vec1[1]*vec2[0];
-  return result;
-}
-
-// operator <<
-template <class T>
-std::ostream& operator<<(std::ostream& aStream, const CVector<T>& aVector) {
-  for (int i = 0; i < aVector.size(); i++)
-    aStream << aVector(i) << '|';
-  aStream << std::endl;
-  return aStream;
-}
-
-#endif
-- 
cgit v1.2.3-70-g09d2