void rspfFilter::createMatrix(NEWMAT::Matrix& m,
long width,
double middle,
double scale)const
{
NEWMAT::ColumnVector colVec(width);
NEWMAT::RowVector rowVec(width);
double t = 0.0;
double val = 0.0;
if(width == 1)
{
t = 0;
val = filter(t, getSupport());
colVec[0] = val;
rowVec[0] = val;
}
else
{
for(long index = 0; index < width; index++)
{
t = (double)index/(double)(width-1);
t = middle + (t - .5)*scale;
val = filter(t, getSupport());
colVec[index] = val;
rowVec[index] = val;
}
}
// do the outer product to construct the
// filter matrix
m = colVec * rowVec;
}
vector<vector<bool>> createVisited(int col,int row){
vector<vector<bool>>ret;
for (int i = 0; i < row; i++) {
vector<bool> rowVec(col,false);
ret.push_back(rowVec);
}
return ret;
}
/* Debugging utility to check if columns have been Inserted into the
* matrix that do not correspond to a row on any processor
*/
void check_for_rogue_columns( Epetra_CrsMatrix& mat) {
// Set up rowVector of 0s and column vector of 1s
const Epetra_Map& rowMap = mat.RowMap();
const Epetra_Map& colMap = mat.ColMap();
Epetra_Vector rowVec(rowMap); rowVec.PutScalar(0.0);
Epetra_Vector colVec(colMap); colVec.PutScalar(1.0);
Epetra_Import importer(colMap, rowMap);
// Overwrite colVec 1s with rowVec 0s
colVec.Import(rowVec, importer, Insert);
// Check that all 1s have been overwritten
double nrm=0.0;
colVec.Norm1(&nrm); // nrm = number of columns not overwritten by rows
// If any rogue columns, exit now (or just get nans later)
if (nrm>=1.0) {
*out << "ERROR: Column map has " << nrm
<< " rogue entries that are not associated with any row." << endl;
rowMap.Comm().Barrier();
exit(-3);
}
}
/**
* @author JIA Pei
* @version 2010-02-22
* @brief Generate all types of window functions
* @param windowSize Input -- the window size
* @param windowFunc Output -- the window function
* @return Mat_<float> return
*/
cv::Mat_<float> VO_WindowFunc::VO_GenerateWindowFunc(cv::Size windowSize, unsigned int windowFunc)
{
cv::Mat_<float> resMat = cv::Mat_<float>::ones(windowSize);
cv::Mat_<float> rowVec = cv::Mat_<float>::ones(1, windowSize.width);
cv::Mat_<float> colVec = cv::Mat_<float>::ones(windowSize.height, 1);
switch(windowFunc)
{
case HAMMING:
{
double a = 2.0 * CV_PI / (windowSize.width - 1.0);
for(unsigned int i = 0; i < windowSize.width; ++i)
rowVec(0, i) = 0.53836 - 0.46164 * cos(a*i);
double b = 2.0 * CV_PI / (windowSize.height - 1.0);
for(unsigned int i = 0; i < windowSize.height; ++i)
colVec(i, 0) = 0.53836 - 0.46164 * cos(b*i);
resMat = colVec*rowVec;
}
break;
case HANN:
{
double a = 2.0 * CV_PI / (windowSize.width - 1.0);
for(unsigned int i = 0; i < windowSize.width; ++i)
rowVec(0, i) = 0.5 * (1.0 - cos(a*i));
double b = 2.0 * CV_PI / (windowSize.height - 1.0);
for(unsigned int i = 0; i < windowSize.height; ++i)
colVec(i, 0) = 0.5 * (1.0 - cos(b*i));
resMat = colVec*rowVec;
}
break;
case TUKEY:
break;
case COSINE:
{
double a = CV_PI / (windowSize.width - 1.0);
for(unsigned int i = 0; i < windowSize.width; ++i)
rowVec(0, i) = sin(a*i);
double b = CV_PI / (windowSize.height - 1.0);
for(unsigned int i = 0; i < windowSize.height; ++i)
colVec(i, 0) = sin(b*i);
resMat = colVec*rowVec;
}
break;
case LANCZOS:
break;
case BARTLETT:
break;
case TRIANGULAR:
break;
case GAUSS:
{
}
break;
case BARTLETTHANN:
break;
case BLACKMAN:
break;
case KAISER:
break;
case NUTTALL:
break;
case BLACKMANHARRIS:
break;
case BLACKMANNUTTALL:
break;
case FLATTOP:
break;
case BESSEL:
break;
case DOLPHCHEBYSHEV:
break;
case EXPONENTIAL:
break;
case RIFEVINCENT:
break;
case GABOR:
break;
case RECTANGULAR:
default:
{
for(unsigned int i = 0; i < windowSize.width; ++i)
for(unsigned int j = 0; j < windowSize.height; ++j)
resMat(i, j) = 1.0f;
}
break;
}
return resMat;
}
static PyObject* Sbk_PathParamFunc_setTable(PyObject* self, PyObject* pyArg)
{
PathParamWrapper* cppSelf = 0;
SBK_UNUSED(cppSelf)
if (!Shiboken::Object::isValid(self))
return 0;
cppSelf = (PathParamWrapper*)((::PathParam*)Shiboken::Conversions::cppPointer(SbkNatronEngineTypes[SBK_PATHPARAM_IDX], (SbkObject*)self));
int overloadId = -1;
PythonToCppFunc pythonToCpp;
SBK_UNUSED(pythonToCpp)
// Overloaded function decisor
// 0: setTable(std::list<std::vector<std::string> >)
if (PySequence_Check(pyArg)) {
overloadId = 0; // setTable(std::list<std::vector<std::string> >)
}
// Function signature not found.
if (overloadId == -1) goto Sbk_PathParamFunc_setTable_TypeError;
// Call function/method
{
if (!PyErr_Occurred()) {
// setTable(std::list<std::vector<std::string> >)
// Begin code injection
if (!PyList_Check(pyArg)) {
PyErr_SetString(PyExc_TypeError, "table must be a list of list objects.");
return 0;
}
std::list<std::vector<std::string> > table;
int size = (int)PyList_GET_SIZE(pyArg);
for (int i = 0; i < size; ++i) {
PyObject* subList = PyList_GET_ITEM(pyArg,i);
if (!subList || !PyList_Check(subList)) {
PyErr_SetString(PyExc_TypeError, "table must be a list of list objects.");
return 0;
}
int subSize = (int)PyList_GET_SIZE(subList);
std::vector<std::string> rowVec(subSize);
for (int j = 0; j < subSize; ++j) {
PyObject* pyString = PyList_GET_ITEM(subList,j);
if ( PyString_Check(pyString) ) {
char* buf = PyString_AsString(pyString);
if (buf) {
std::string ret;
ret.append(buf);
rowVec[j] = ret;
}
} else if (PyUnicode_Check(pyString) ) {
PyObject* utf8pyobj = PyUnicode_AsUTF8String(pyString); // newRef
if (utf8pyobj) {
char* cstr = PyBytes_AS_STRING(utf8pyobj); // Borrowed pointer
std::string ret;
ret.append(cstr);
Py_DECREF(utf8pyobj);
rowVec[j] = ret;
}
}
}
table.push_back(rowVec);
}
cppSelf->setTable(table);
// End of code injection
}
}
if (PyErr_Occurred()) {
return 0;
}
Py_RETURN_NONE;
Sbk_PathParamFunc_setTable_TypeError:
const char* overloads[] = {"list", 0};
Shiboken::setErrorAboutWrongArguments(pyArg, "NatronEngine.PathParam.setTable", overloads);
return 0;
}
