Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source
pull/13383/head
Vadim Pisarevsky 15 years ago
parent f2df784830
commit 08b7855edc
6 changed files with 455 additions and 226 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      modules/core/include/opencv2/core/core.hpp
  2. 79
      modules/core/include/opencv2/core/cvout.hpp
  3. 101
      modules/core/include/opencv2/core/operations.hpp
  4. 381
      modules/core/src/cvout.cpp
  5. 52
      modules/features2d/src/brief.cpp
  6. 45
      samples/cpp/cvout_sample.cpp

1
modules/core/include/opencv2/core/core.hpp
Unescape 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
Unescape 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
Unescape View File

@ -3496,6 +3496,107 @@ public:
} }
}; };
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;
}
} }
#endif // __cplusplus #endif // __cplusplus

381
modules/core/src/cvout.cpp
Unescape 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; template<typename _Tp> static void writeElems(std::ostream& out, const _Tp* data,
/* Draw Me: int nelems, int cn, char obrace, char cbrace)
plot2( pts1(:,1),pts1(:,2),'r.') */
std::streamsize pp = out.precision();
out.precision(15);
out << "[";
CIT it = points.begin();
for (; it != points.end(); ++it)
{
out << *it;
CIT next = it;
if (++next != points.end())
{
out << " ";
}
}
out << "]";
out.precision(pp);
return out;
}
std::ostream & writeelem(std::ostream & out, const Mat & mat, int i, int j)
{ {
if (mat.type() == CV_32F) typedef typename DataType<_Tp>::work_type _WTp;
out << mat.at<float> (i, j); nelems *= cn;
else if (mat.type() == CV_64F) for(int i = 0; i < nelems; i += cn)
out << mat.at<double> (i, j); {
else if (mat.type() == CV_32S) if(cn == 1)
out << mat.at<int> (i, j); {
else if (mat.type() == CV_8U) out << (_WTp)data[i] << (i+1 < nelems ? ", " : "");
out << int(mat.at<unsigned char> (i, j)); continue;
else if (mat.type() == CV_16U) }
out << int(mat.at<unsigned short> (i, j)); out << obrace;
else for(int j = 0; j < cn; j++)
out << "?"; out << (_WTp)data[i + j] << (j+1 < cn ? ", " : "");
return out; out << cbrace << (i+cn < nelems ? ", " : "");
}
} }
static void writeElems(std::ostream& out, const void* data, int nelems, int type, char brace)
{
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
char cbrace = ' ';
if(!brace || isspace(brace))
{
nelems *= cn;
cn = 1;
}
else
cbrace = getCloseBrace(brace);
if(depth == CV_8U)
writeElems(out, (const uchar*)data, nelems, cn, brace, cbrace);
else if(depth == CV_8S)
writeElems(out, (const schar*)data, nelems, cn, brace, cbrace);
else if(depth == CV_16U)
writeElems(out, (const ushort*)data, nelems, cn, brace, cbrace);
else if(depth == CV_16S)
writeElems(out, (const short*)data, nelems, cn, brace, cbrace);
else if(depth == CV_32S)
writeElems(out, (const int*)data, nelems, cn, brace, cbrace);
else if(depth == CV_32F)
{
std::streamsize pp = out.precision();
out.precision(8);
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, "");
} }
std::ostream & operator<<(std::ostream & out, const std::vector<Point2f> & points)
static void writeMat(std::ostream& out, const Mat& m, char rowsep, char elembrace, bool singleLine)
{ {
return writevec(out, points); 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 ";
}
}
} }
std::ostream & operator<<(std::ostream & out, const std::vector<Point3f> & points)
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)
{ {
return writevec(out, points); 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;
} }
std::ostream & operator<<(std::ostream & out, const Mat & _mat) const Formatter* Formatter::get(const char* fmt)
{ {
std::streamsize pp = out.precision(); if(!fmt || my_streq(fmt, ""))
out.precision(15); return g_defaultFormatter;
std::vector<Mat> channels; if( my_streq(fmt, "MATLAB"))
split(_mat, channels); return &matlabFormatter;
for (int chn = 0; chn < _mat.channels(); chn++) if( my_streq(fmt, "CSV"))
{ return &csvFormatter;
Mat mat = channels[chn]; if( my_streq(fmt, "PYTHON"))
out << "["; return &pythonFormatter;
for (int i = 0; i < mat.rows; i++) if( my_streq(fmt, "NUMPY"))
{ return &numpyFormatter;
for (int j = 0; j < mat.cols; j++) if( my_streq(fmt, "C"))
{ return &cFormatter;
writeelem(out,mat,i,j); CV_Error(CV_StsBadArg, "Unknown formatter");
if (j < mat.cols - 1) return g_defaultFormatter;
out << " ";
}
if (i < mat.rows - 1)
out << ";\n";
}
out << "]";
}
out.precision(pp);
return out;
} }
std::ostream & writeCSV(std::ostream & out, const std::vector<Point3f> & points) const Formatter* Formatter::setDefault(const Formatter* fmt)
{ {
std::streamsize pp = out.precision(); const Formatter* prevFmt = g_defaultFormatter;
out.precision(15); if(!fmt)
std::vector<Point3f>::const_iterator it = points.begin(); fmt = g_defaultFormatter0;
g_defaultFormatter = fmt;
for (; it != points.end(); ++it) return prevFmt;
{
out << it->x << "," << it->y << ","<< it->z << "\n";
}
out.precision(pp);
return out;
} }
std::ostream & writeCSV(std::ostream & out, const std::vector<Point2f> & points) Formatted::Formatted(const Mat& _m, const Formatter* _fmt,
const vector<int>& _params)
{ {
std::streamsize pp = out.precision(); mtx = _m;
out.precision(15); fmt = _fmt ? _fmt : Formatter::get();
std::vector<Point2f>::const_iterator it = points.begin(); std::copy(_params.begin(), _params.end(), back_inserter(params));
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) Formatted::Formatted(const Mat& _m, const Formatter* _fmt, const int* _params)
{ {
std::streamsize pp = out.precision(); mtx = _m;
out.precision(15); fmt = _fmt ? _fmt : Formatter::get();
for (int i = 0; i < mat.rows; i++)
{
for (int j = 0; j < mat.cols; j++) if( _params )
{ {
writeelem(out,mat,i,j); int i, maxParams = 100;
if (j < mat.cols - 1) for(i = 0; i < maxParams && _params[i] != 0; i+=2)
out << ","; ;
std::copy(_params, _params + i, back_inserter(params));
} }
out << "\n";
}
out.precision(pp);
return out;
} }
} }

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

@ -1,11 +1,49 @@
#include <opencv2/features2d/features2d.hpp> /*M///////////////////////////////////////////////////////////////////////////////////////
#include <opencv2/imgproc/imgproc.hpp> //
#include <algorithm> // 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 <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

45
samples/cpp/cvout_sample.cpp
Unescape 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 << "#csv" << endl; cout << "shortvec = " << Mat(v) << endl;
writeCSV(cout, r); vector<Point2f> points(20);
for (size_t i = 0; i < points.size(); ++i)
points[i] = Point2f(i * 5, i % 7);
return 1; cout << "points = " << points << ";" << endl;
return 0;
} }

Write Preview
Loading…
Cancel
Save