generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

extended out << mat/vec operators; added opencv license

Browse Source
This commit is contained in:
Vadim Pisarevsky 2010-11-15 17:40:57 +00:00
parent f2df784830
commit 08b7855edc
6 changed files with 457 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
modules/core/include/opencv2/core/core.hpp
View File

@ -4055,6 +4055,5 @@ public:
#include "opencv2/core/operations.hpp" #include "opencv2/core/operations.hpp"
#include "opencv2/core/mat.hpp" #include "opencv2/core/mat.hpp"
#include "opencv2/core/cvout.hpp"
#endif /*__OPENCV_CORE_HPP__*/ #endif /*__OPENCV_CORE_HPP__*/

79
modules/core/include/opencv2/core/cvout.hpp
View File

@ -1,79 +0,0 @@
#ifndef __OPENCV_CORE_CVOUT_HPP__
#define __OPENCV_CORE_CVOUT_HPP__
#ifdef __cplusplus
#ifndef SKIP_INCLUDES
#include <iomanip>
#include <iostream>
#include <vector>
#endif
namespace cv
{
/** Writes a point to an output stream in Matlab notation
*/
inline std::ostream & operator<<(std::ostream & out, const Point2f & p)
{
out << "[ " << p.x << "," << p.y << " ]";
return out;
}
/** Writes a point to an output stream in Matlab notation
*/
inline std::ostream & operator<<(std::ostream & out, const Point3f & p)
{
out << "[ " << p.x << "," << p.y << "," << p.z << " ]";
return out;
}
/** \brief write points to and output stream
* \param out typically cout
* \param points the points to be written to the stream
* \return the stream
**/
CV_EXPORTS std::ostream & operator<<(std::ostream & out, const std::vector<Point2f> & points);
/** \brief write points to and output stream
* \param out typically cout
* \param points the points to be written to the stream
* \return the stream
**/
std::ostream & operator<<(std::ostream & out, const std::vector<Point3f> & points);
/** \brief allows each output of Mat in Matlab for Mat to std::cout
* use like
@verbatim
Mat my_mat = Mat::eye(3,3,CV_32F);
std::cout << my_mat;
@endverbatim
*/
CV_EXPORTS std::ostream & operator<<(std::ostream & out, const Mat & mat);
/** \brief write a Mat in csv compatible for Matlab.
This means that the rows are seperated by newlines and the
columns by commas ....
331.413896619595,0,122.365880226491
0,249.320451610369,122.146722131871
0,0,1
* \param out output stream to write to
* \param Mat write a Mat to a csv
*/
CV_EXPORTS std::ostream & writeCSV(std::ostream & out, const Mat & mat);
/** \brief write a vector of points to an
output stream if possible
**/
CV_EXPORTS std::ostream & writeCSV(std::ostream & out, const std::vector<Point2f> & points);
/** \brief write a vector of points to an
output stream if possible
**/
CV_EXPORTS std::ostream & writeCSV(std::ostream & out, const std::vector<Point3f> & points);
} //namespace cv
#endif
#endif

101
modules/core/include/opencv2/core/operations.hpp
View File

@ -3495,6 +3495,107 @@ public:
return new _ClsName(*(const _ClsName*)ptr); return new _ClsName(*(const _ClsName*)ptr);
} }
}; };
class CV_EXPORTS Formatter
{
public:
virtual ~Formatter() {}
virtual void write(std::ostream& out, const Mat& m, const int* params=0, int nparams=0) const = 0;
virtual void write(std::ostream& out, const void* data, int nelems, int type,
const int* params=0, int nparams=0) const = 0;
static const Formatter* get(const char* fmt="");
static const Formatter* setDefault(const Formatter* fmt);
};
struct CV_EXPORTS Formatted
{
Formatted(const Mat& m, const Formatter* fmt,
const vector<int>& params);
Formatted(const Mat& m, const Formatter* fmt,
const int* params=0);
Mat mtx;
const Formatter* fmt;
vector<int> params;
};
/** Writes a point to an output stream in Matlab notation
*/
template<typename _Tp> inline std::ostream& operator<<(std::ostream& out, const Point_<_Tp>& p)
{
out << "[" << p.x << ", " << p.y << "]";
return out;
}
/** Writes a point to an output stream in Matlab notation
*/
template<typename _Tp> inline std::ostream& operator<<(std::ostream& out, const Point3_<_Tp>& p)
{
out << "[" << p.x << ", " << p.y << ", " << p.z << "]";
return out;
}
static inline Formatted format(const Mat& mtx, const char* fmt,
const vector<int>& params=vector<int>())
{
return Formatted(mtx, Formatter::get(fmt), params);
}
template<typename _Tp> static inline Formatted format(const vector<Point_<_Tp> >& vec,
const char* fmt, const vector<int>& params=vector<int>())
{
return Formatted(Mat(vec), Formatter::get(fmt), params);
}
template<typename _Tp> static inline Formatted format(const vector<Point3_<_Tp> >& vec,
const char* fmt, const vector<int>& params=vector<int>())
{
return Formatted(Mat(vec), Formatter::get(fmt), params);
}
/** \brief prints Mat to the output stream in Matlab notation
* use like
@verbatim
Mat my_mat = Mat::eye(3,3,CV_32F);
std::cout << my_mat;
@endverbatim
*/
static inline std::ostream& operator << (std::ostream& out, const Mat& mtx)
{
Formatter::get()->write(out, mtx);
return out;
}
/** \brief prints Mat to the output stream allows in the specified notation (see format)
* use like
@verbatim
Mat my_mat = Mat::eye(3,3,CV_32F);
std::cout << my_mat;
@endverbatim
*/
static inline std::ostream& operator << (std::ostream& out, const Formatted& fmtd)
{
fmtd.fmt->write(out, fmtd.mtx);
return out;
}
template<typename _Tp> static inline std::ostream& operator << (std::ostream& out,
const vector<Point_<_Tp> >& vec)
{
Formatter::get()->write(out, Mat(vec));
return out;
}
template<typename _Tp> static inline std::ostream& operator << (std::ostream& out,
const vector<Point3_<_Tp> >& vec)
{
Formatter::get()->write(out, Mat(vec));
return out;
}
} }

403
modules/core/src/cvout.cpp
View File

@ -1,138 +1,305 @@
#include "opencv2/core/core.hpp" /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"
#include <iterator>
namespace cv namespace cv
{ {
namespace static inline char getCloseBrace(char c)
{ {
template<typename T> return c == '[' ? ']' : c == '(' ? ')' : c == '{' ? '}' : '\0';
std::ostream & writevec(std::ostream & out, const std::vector<T> & points) }
{
typedef T MT_T;
typedef typename std::vector<T>::const_iterator CIT;
/* Draw Me:
plot2( pts1(:,1),pts1(:,2),'r.') */
std::streamsize pp = out.precision();
out.precision(15);
out << "[";
CIT it = points.begin();
for (; it != points.end(); ++it) template<typename _Tp> static void writeElems(std::ostream& out, const _Tp* data,
int nelems, int cn, char obrace, char cbrace)
{
typedef typename DataType<_Tp>::work_type _WTp;
nelems *= cn;
for(int i = 0; i < nelems; i += cn)
{ {
if(cn == 1)
out << *it; {
CIT next = it; out << (_WTp)data[i] << (i+1 < nelems ? ", " : "");
if (++next != points.end()) continue;
{ }
out << " "; out << obrace;
} for(int j = 0; j < cn; j++)
out << (_WTp)data[i + j] << (j+1 < cn ? ", " : "");
out << cbrace << (i+cn < nelems ? ", " : "");
} }
out << "]";
out.precision(pp);
return out;
}
std::ostream & writeelem(std::ostream & out, const Mat & mat, int i, int j)
{
if (mat.type() == CV_32F)
out << mat.at<float> (i, j);
else if (mat.type() == CV_64F)
out << mat.at<double> (i, j);
else if (mat.type() == CV_32S)
out << mat.at<int> (i, j);
else if (mat.type() == CV_8U)
out << int(mat.at<unsigned char> (i, j));
else if (mat.type() == CV_16U)
out << int(mat.at<unsigned short> (i, j));
else
out << "?";
return out;
} }
}
std::ostream & operator<<(std::ostream & out, const std::vector<Point2f> & points) static void writeElems(std::ostream& out, const void* data, int nelems, int type, char brace)
{ {
return writevec(out, points); int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
} char cbrace = ' ';
std::ostream & operator<<(std::ostream & out, const std::vector<Point3f> & points) if(!brace || isspace(brace))
{
return writevec(out, points);
}
std::ostream & operator<<(std::ostream & out, const Mat & _mat)
{
std::streamsize pp = out.precision();
out.precision(15);
std::vector<Mat> channels;
split(_mat, channels);
for (int chn = 0; chn < _mat.channels(); chn++)
{
Mat mat = channels[chn];
out << "[";
for (int i = 0; i < mat.rows; i++)
{ {
for (int j = 0; j < mat.cols; j++) nelems *= cn;
{ cn = 1;
writeelem(out,mat,i,j);
if (j < mat.cols - 1)
out << " ";
}
if (i < mat.rows - 1)
out << ";\n";
} }
out << "]"; else
} cbrace = getCloseBrace(brace);
out.precision(pp); if(depth == CV_8U)
return out; writeElems(out, (const uchar*)data, nelems, cn, brace, cbrace);
} else if(depth == CV_8S)
writeElems(out, (const schar*)data, nelems, cn, brace, cbrace);
std::ostream & writeCSV(std::ostream & out, const std::vector<Point3f> & points) else if(depth == CV_16U)
{ writeElems(out, (const ushort*)data, nelems, cn, brace, cbrace);
std::streamsize pp = out.precision(); else if(depth == CV_16S)
out.precision(15); writeElems(out, (const short*)data, nelems, cn, brace, cbrace);
std::vector<Point3f>::const_iterator it = points.begin(); else if(depth == CV_32S)
writeElems(out, (const int*)data, nelems, cn, brace, cbrace);
for (; it != points.end(); ++it) else if(depth == CV_32F)
{
out << it->x << "," << it->y << ","<< it->z << "\n";
}
out.precision(pp);
return out;
}
std::ostream & writeCSV(std::ostream & out, const std::vector<Point2f> & points)
{
std::streamsize pp = out.precision();
out.precision(15);
std::vector<Point2f>::const_iterator it = points.begin();
for (; it != points.end(); ++it)
{
out << it->x << "," << it->y << "\n";
}
out.precision(pp);
return out;
}
std::ostream & writeCSV(std::ostream & out, const Mat & mat)
{
std::streamsize pp = out.precision();
out.precision(15);
for (int i = 0; i < mat.rows; i++)
{
for (int j = 0; j < mat.cols; j++)
{ {
writeelem(out,mat,i,j); std::streamsize pp = out.precision();
if (j < mat.cols - 1) out.precision(8);
out << ","; writeElems(out, (const float*)data, nelems, cn, brace, cbrace);
out.precision(pp);
}
else if(depth == CV_64F)
{
std::streamsize pp = out.precision();
out.precision(16);
writeElems(out, (const double*)data, nelems, cn, brace, cbrace);
out.precision(pp);
}
else
CV_Error(CV_StsUnsupportedFormat, "");
}
static void writeMat(std::ostream& out, const Mat& m, char rowsep, char elembrace, bool singleLine)
{
CV_Assert(m.dims <= 2);
int type = m.type();
char crowbrace = getCloseBrace(rowsep);
char orowbrace = crowbrace ? rowsep : '\0';
if( orowbrace || isspace(rowsep) )
rowsep = '\0';
for( int i = 0; i < m.rows; i++ )
{
if(orowbrace)
out << orowbrace;
writeElems(out, m.ptr(i), m.cols, type, elembrace);
if(orowbrace)
out << crowbrace << (i+1 < m.rows ? ", " : "");
if(i+1 < m.rows)
{
if(rowsep)
out << rowsep << (singleLine ? " " : "");
if(!singleLine)
out << "\n ";
}
}
}
class MatlabFormatter : public Formatter
{
public:
virtual ~MatlabFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
{
out << "[";
writeMat(out, m, ';', ' ', m.cols == 1);
out << "]";
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, ' ');
}
};
class PythonFormatter : public Formatter
{
public:
virtual ~PythonFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
{
out << "[";
writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.cols*m.channels() == 1);
out << "]";
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, '[');
}
};
class NumpyFormatter : public Formatter
{
public:
virtual ~NumpyFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
{
static const char* numpyTypes[] =
{
"uint8", "int8", "uint16", "int16", "int32", "float32", "float64", "uint64"
};
out << "array([";
writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.cols*m.channels() == 1);
out << "], type='" << numpyTypes[m.depth()] << "')";
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, '[');
}
};
class CSVFormatter : public Formatter
{
public:
virtual ~CSVFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
{
writeMat(out, m, ' ', ' ', m.cols*m.channels() == 1);
if(m.rows > 1)
out << "\n";
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, ' ');
}
};
class CFormatter : public Formatter
{
public:
virtual ~CFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
{
out << "{";
writeMat(out, m, ',', ' ', m.cols==1);
out << "}";
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, ' ');
}
};
static MatlabFormatter matlabFormatter;
static PythonFormatter pythonFormatter;
static NumpyFormatter numpyFormatter;
static CSVFormatter csvFormatter;
static CFormatter cFormatter;
static const Formatter* g_defaultFormatter0 = &matlabFormatter;
static const Formatter* g_defaultFormatter = &matlabFormatter;
bool my_streq(const char* a, const char* b)
{
size_t i, alen = strlen(a), blen = strlen(b);
if( alen != blen )
return false;
for( i = 0; i < alen; i++ )
if( a[i] != b[i] && a[i] - 32 != b[i] )
return false;
return true;
}
const Formatter* Formatter::get(const char* fmt)
{
if(!fmt || my_streq(fmt, ""))
return g_defaultFormatter;
if( my_streq(fmt, "MATLAB"))
return &matlabFormatter;
if( my_streq(fmt, "CSV"))
return &csvFormatter;
if( my_streq(fmt, "PYTHON"))
return &pythonFormatter;
if( my_streq(fmt, "NUMPY"))
return &numpyFormatter;
if( my_streq(fmt, "C"))
return &cFormatter;
CV_Error(CV_StsBadArg, "Unknown formatter");
return g_defaultFormatter;
}
const Formatter* Formatter::setDefault(const Formatter* fmt)
{
const Formatter* prevFmt = g_defaultFormatter;
if(!fmt)
fmt = g_defaultFormatter0;
g_defaultFormatter = fmt;
return prevFmt;
}
Formatted::Formatted(const Mat& _m, const Formatter* _fmt,
const vector<int>& _params)
{
mtx = _m;
fmt = _fmt ? _fmt : Formatter::get();
std::copy(_params.begin(), _params.end(), back_inserter(params));
}
Formatted::Formatted(const Mat& _m, const Formatter* _fmt, const int* _params)
{
mtx = _m;
fmt = _fmt ? _fmt : Formatter::get();
if( _params )
{
int i, maxParams = 100;
for(i = 0; i < maxParams && _params[i] != 0; i+=2)
;
std::copy(_params, _params + i, back_inserter(params));
} }
out << "\n";
}
out.precision(pp);
return out;
} }
} }

52
modules/features2d/src/brief.cpp
View File

@ -1,11 +1,49 @@
#include <opencv2/features2d/features2d.hpp> /*M///////////////////////////////////////////////////////////////////////////////////////
#include <opencv2/imgproc/imgproc.hpp> //
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009-2010, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "precomp.hpp"
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
using std::vector;
namespace cv namespace cv
{ {
@ -362,8 +400,4 @@ unsigned char HammingLUT::byteBitsLookUp(unsigned char b){
return table[b]; return table[b];
} }
} // namespace cv } // namespace cv

49
samples/cpp/cvout_sample.cpp
View File

@ -1,34 +1,41 @@
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
#include <iostream>
using namespace std; using namespace std;
using namespace cv; using namespace cv;
int main() int main(int,char**)
{ {
Mat i = Mat::eye(4, 4, CV_32F); Mat i = Mat::eye(4, 4, CV_64F);
cout << "i = " << i << ";" << endl; i.at<double>(1,1) = CV_PI;
cout << "i = " << i << ";" << endl;
Mat r = Mat(10, 10, CV_8UC1); Mat r = Mat(10, 3, CV_8UC3);
randu(r, Scalar(0), Scalar(255)); randu(r, Scalar::all(0), Scalar::all(255));
cout << "r = " << r << ";" << endl; cout << "r (default) = " << r << ";" << endl << endl;
cout << "r (python) = " << format(r,"python") << ";" << endl << endl;
cout << "r (numpy) = " << format(r,"numpy") << ";" << endl << endl;
cout << "r (csv) = " << format(r,"csv") << ";" << endl << endl;
cout << "r (c) = " << format(r,"C") << ";" << endl << endl;
Point2f p(5, 1); Point2f p(5, 1);
cout << "p = " << p << ";" << endl; cout << "p = " << p << ";" << endl;
Point3f p3f(2, 6, 7); Point3f p3f(2, 6, 7);
cout << "p3f = " << p3f << ";" << endl; cout << "p3f = " << p3f << ";" << endl;
vector<Point2f> points(20); vector<float> v;
for (size_t i = 0; i < points.size(); ++i) v.push_back(1);
{ v.push_back(2);
points[i] = Point2f(i * 5, i % 7); v.push_back(3);
}
cout << "points = " << points << ";" << endl; cout << "shortvec = " << Mat(v) << endl;
vector<Point2f> points(20);
for (size_t i = 0; i < points.size(); ++i)
points[i] = Point2f(i * 5, i % 7);
cout << "#csv" << endl; cout << "points = " << points << ";" << endl;
return 0;
writeCSV(cout, r);
return 1;
} }