Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rewrite Mat formatting without std streams

Browse Source
pull/747/head
Andrey Kamaev 12 years ago
parent 7193a73ca0
commit c979de1eed
7 changed files with 365 additions and 296 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 104
      modules/core/include/opencv2/core/operations.hpp
  2. 45
      modules/core/include/opencv2/core/traits.hpp
  3. 487
      modules/core/src/out.cpp
  4. 1
      modules/core/test/test_io.cpp
  5. 4
      modules/highgui/src/window_gtk.cpp
  6. 12
      samples/cpp/cout_mat.cpp
  7. 8
      samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp

104
modules/core/include/opencv2/core/operations.hpp
Unescape View File

@ -400,96 +400,80 @@ template<typename _Tp> static inline _Tp randu()
//////////////////////////////////////////////////////////////////////////////
class CV_EXPORTS Formatter
class CV_EXPORTS Formatted
{
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);
virtual const char* next() = 0;
virtual void reset() = 0;
virtual ~Formatted();
};
struct CV_EXPORTS Formatted
class CV_EXPORTS Formatter
{
Formatted(const Mat& m, const Formatter* fmt,
const std::vector<int>& params);
Formatted(const Mat& m, const Formatter* fmt,
const int* params=0);
Mat mtx;
const Formatter* fmt;
std::vector<int> params;
};
public:
enum { FMT_MATLAB = 0,
FMT_CSV = 1,
FMT_PYTHON = 2,
FMT_NUMPY = 3,
FMT_C = 4,
FMT_DEFAULT = FMT_MATLAB
};
static inline Formatted format(const Mat& mtx, const char* fmt,
const std::vector<int>& params=std::vector<int>())
{
return Formatted(mtx, Formatter::get(fmt), params);
}
virtual ~Formatter();
template<typename _Tp> static inline Formatted format(const std::vector<Point_<_Tp> >& vec,
const char* fmt, const std::vector<int>& params=std::vector<int>())
{
return Formatted(Mat(vec), Formatter::get(fmt), params);
}
virtual Ptr<Formatted> format(const Mat& mtx) const = 0;
virtual void set32fPrecision(int p = 8) = 0;
virtual void set64fPrecision(int p = 16) = 0;
virtual void setMultiline(bool ml = true) = 0;
template<typename _Tp> static inline Formatted format(const std::vector<Point3_<_Tp> >& vec,
const char* fmt, const std::vector<int>& params=std::vector<int>())
static Ptr<Formatter> get(int fmt = FMT_DEFAULT);
};
static inline
Ptr<Formatted> format(InputArray mtx, int fmt)
{
return Formatted(Mat(vec), Formatter::get(fmt), params);
return Formatter::get(fmt)->format(mtx.getMat());
}
/** \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)
static inline
std::ostream& operator << (std::ostream& out, Ptr<Formatted> fmtd)
{
Formatter::get()->write(out, mtx);
fmtd->reset();
for(const char* str = fmtd->next(); str; str = fmtd->next())
out << str;
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)
static inline
std::ostream& operator << (std::ostream& out, const Mat& mtx)
{
fmtd.fmt->write(out, fmtd.mtx);
return out;
return out << Formatter::get()->format(mtx);
}
template<typename _Tp> static inline std::ostream& operator << (std::ostream& out,
const std::vector<Point_<_Tp> >& vec)
template<typename _Tp> static inline
std::ostream& operator << (std::ostream& out, const std::vector<Point_<_Tp> >& vec)
{
Formatter::get()->write(out, Mat(vec));
return out;
return out << Formatter::get()->format(Mat(vec));
}
template<typename _Tp> static inline std::ostream& operator << (std::ostream& out,
const std::vector<Point3_<_Tp> >& vec)
template<typename _Tp> static inline
std::ostream& operator << (std::ostream& out, const std::vector<Point3_<_Tp> >& vec)
{
Formatter::get()->write(out, Mat(vec));
return out;
return out << Formatter::get()->format(Mat(vec));
}
/** Writes a Matx to an output stream.
*/
template<typename _Tp, int m, int n> inline std::ostream& operator<<(std::ostream& out, const Matx<_Tp, m, n>& matx)
template<typename _Tp, int m, int n> inline
std::ostream& operator << (std::ostream& out, const Matx<_Tp, m, n>& matx)
{
out << cv::Mat(matx);
return out;
return out << Formatter::get()->format(matx);
}
/** Writes a point to an output stream in Matlab notation

45
modules/core/include/opencv2/core/traits.hpp
Unescape View File

@ -227,6 +227,51 @@ public:
};
};
template<int depth> class TypeDepth {};
template<> class TypeDepth<CV_8U>
{
enum { depth = CV_8U };
typedef uchar value_type;
};
template<> class TypeDepth<CV_8S>
{
enum { depth = CV_8S };
typedef schar value_type;
};
template<> class TypeDepth<CV_16U>
{
enum { depth = CV_16U };
typedef ushort value_type;
};
template<> class TypeDepth<CV_16S>
{
enum { depth = CV_16S };
typedef short value_type;
};
template<> class TypeDepth<CV_32S>
{
enum { depth = CV_32S };
typedef int value_type;
};
template<> class TypeDepth<CV_32F>
{
enum { depth = CV_32F };
typedef float value_type;
};
template<> class TypeDepth<CV_64F>
{
enum { depth = CV_64F };
typedef double value_type;
};
} // cv
#endif // __OPENCV_CORE_TRAITS_HPP__

487
modules/core/src/out.cpp
Unescape View File

@ -11,7 +11,8 @@
// 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.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
@ -41,267 +42,305 @@
//M*/
#include "precomp.hpp"
#include <iterator>
namespace cv
namespace
{
class FormattedImpl : public cv::Formatted
{
enum { STATE_PROLOGUE, STATE_EPILOGUE, STATE_ROW_OPEN, STATE_ROW_CLOSE, STATE_CN_OPEN, STATE_CN_CLOSE, STATE_VALUE, STATE_FINISHED,
STATE_LINE_SEPARATOR, STATE_CN_SEPARATOR, STATE_VALUE_SEPARATOR };
enum {BRACE_ROW_OPEN = 0, BRACE_ROW_CLOSE = 1, BRACE_ROW_SEP=2, BRACE_CN_OPEN=3, BRACE_CN_CLOSE=4 };
static inline char getCloseBrace(char c)
{
return c == '[' ? ']' : c == '(' ? ')' : c == '{' ? '}' : '\0';
}
char floatFormat[8];
char buf[32]; // enough for double with precision up to 20
cv::Mat mtx;
int mcn;
bool singleLine;
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 << (_WTp)data[i] << (i+1 < nelems ? ", " : "");
continue;
}
out << obrace;
for(int j = 0; j < cn; j++)
out << (_WTp)data[i + j] << (j+1 < cn ? ", " : "");
out << cbrace << (i+cn < nelems ? ", " : "");
}
}
int state;
int row;
int col;
int cn;
cv::String prologue;
cv::String epilogue;
char braces[5];
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, "");
}
void (FormattedImpl::*valueToStr)();
void valueToStr8u() { sprintf(buf, "%3d", (int)mtx.ptr<uchar>(row, col)[cn]); }
void valueToStr8s() { sprintf(buf, "%3d", (int)mtx.ptr<schar>(row, col)[cn]); }
void valueToStr16u() { sprintf(buf, "%d", (int)mtx.ptr<ushort>(row, col)[cn]); }
void valueToStr16s() { sprintf(buf, "%d", (int)mtx.ptr<short>(row, col)[cn]); }
void valueToStr32s() { sprintf(buf, "%d", mtx.ptr<int>(row, col)[cn]); }
void valueToStr32f() { sprintf(buf, floatFormat, mtx.ptr<float>(row, col)[cn]); }
void valueToStr64f() { sprintf(buf, floatFormat, mtx.ptr<double>(row, col)[cn]); }
void valueToStrOther() { buf[0] = 0; }
static void writeMat(std::ostream& out, const Mat& m, char rowsep, char elembrace, bool singleLine)
{
CV_Assert(m.dims <= 2);
int type = m.type();
public:
char crowbrace = getCloseBrace(rowsep);
char orowbrace = crowbrace ? rowsep : '\0';
FormattedImpl(cv::String pl, cv::String el, cv::Mat m, char br[5], bool sLine, int precision)
{
prologue = pl;
epilogue = el;
mtx = m;
mcn = m.channels();
memcpy(braces, br, 5);
state = STATE_PROLOGUE;
singleLine = sLine;
if (precision < 0)
{
floatFormat[0] = '%';
floatFormat[1] = 'a';
floatFormat[2] = 0;
}
else
{
sprintf(floatFormat, "%%.%dg", std::min(precision, 20));
}
switch(mtx.depth())
{
case CV_8U: valueToStr = &FormattedImpl::valueToStr8u; break;
case CV_8S: valueToStr = &FormattedImpl::valueToStr8s; break;
case CV_16U: valueToStr = &FormattedImpl::valueToStr16u; break;
case CV_16S: valueToStr = &FormattedImpl::valueToStr16s; break;
case CV_32S: valueToStr = &FormattedImpl::valueToStr32s; break;
case CV_32F: valueToStr = &FormattedImpl::valueToStr32f; break;
case CV_64F: valueToStr = &FormattedImpl::valueToStr64f; break;
default: valueToStr = &FormattedImpl::valueToStrOther; break;
}
}
if( orowbrace || isspace(rowsep) )
rowsep = '\0';
void reset()
{
state = STATE_PROLOGUE;
}
for( int i = 0; i < m.rows; i++ )
{
if(orowbrace)
out << orowbrace;
if( m.data )
writeElems(out, m.ptr(i), m.cols, type, elembrace);
if(orowbrace)
out << crowbrace << (i+1 < m.rows ? ", " : "");
if(i+1 < m.rows)
const char* next()
{
if(rowsep)
out << rowsep << (singleLine ? " " : "");
if(!singleLine)
out << "\n ";
switch(state)
{
case STATE_PROLOGUE:
row = 0;
if (mtx.empty())
state = STATE_EPILOGUE;
else
state = STATE_ROW_OPEN;
return prologue.c_str();
case STATE_EPILOGUE:
state = STATE_FINISHED;
return epilogue.c_str();
case STATE_ROW_OPEN:
col = 0;
state = STATE_CN_OPEN;
{
size_t pos = 0;
if (row > 0)
while(pos < prologue.size() && pos < sizeof(buf) - 2)
buf[pos++] = ' ';
if (braces[BRACE_ROW_OPEN])
buf[pos++] = braces[BRACE_ROW_OPEN];
if(!pos)
return next();
buf[pos] = 0;
}
return buf;
case STATE_ROW_CLOSE:
state = STATE_LINE_SEPARATOR;
++row;
if (braces[BRACE_ROW_CLOSE])
{
buf[0] = braces[BRACE_ROW_CLOSE];
buf[1] = row < mtx.rows ? ',' : '\0';
buf[2] = 0;
return buf;
}
else if(braces[BRACE_ROW_SEP] && row < mtx.rows)
{
buf[0] = braces[BRACE_ROW_SEP];
buf[1] = 0;
return buf;
}
return next();
case STATE_CN_OPEN:
cn = 0;
state = STATE_VALUE;
if (mcn > 1 && braces[BRACE_CN_OPEN])
{
buf[0] = braces[BRACE_CN_OPEN];
buf[1] = 0;
return buf;
}
return next();
case STATE_CN_CLOSE:
++col;
if (col >= mtx.cols)
state = STATE_ROW_CLOSE;
else
state = STATE_CN_SEPARATOR;
if (mcn > 1 && braces[BRACE_CN_CLOSE])
{
buf[0] = braces[BRACE_CN_CLOSE];
buf[1] = 0;
return buf;
}
return next();
case STATE_VALUE:
(this->*valueToStr)();
if (++cn >= mcn)
state = STATE_CN_CLOSE;
else
state = STATE_VALUE_SEPARATOR;
return buf;
case STATE_FINISHED:
return 0;
case STATE_LINE_SEPARATOR:
if (row >= mtx.rows)
{
state = STATE_EPILOGUE;
return next();
}
state = STATE_ROW_OPEN;
buf[0] = singleLine ? ' ' : '\n';
buf[1] = 0;
return buf;
case STATE_CN_SEPARATOR:
state = STATE_CN_OPEN;
buf[0] = ',';
buf[1] = ' ';
buf[2] = 0;
return buf;
case STATE_VALUE_SEPARATOR:
state = STATE_VALUE;
buf[0] = ',';
buf[1] = ' ';
buf[2] = 0;
return buf;
}
return 0;
}
}
}
};
class MatlabFormatter : public Formatter
{
public:
virtual ~MatlabFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
class FormatterBase : public cv::Formatter
{
out << "[";
writeMat(out, m, ';', ' ', m.cols == 1);
out << "]";
}
public:
FormatterBase() : prec32f(8), prec64f(16), multiline(true) {}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, ' ');
}
};
void set32fPrecision(int p)
{
prec32f = p;
}
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 set64fPrecision(int p)
{
prec64f = p;
}
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
{
writeElems(out, data, nelems, type, '[');
}
};
void setMultiline(bool ml)
{
multiline = ml;
}
protected:
int prec32f;
int prec64f;
int multiline;
};
class NumpyFormatter : public Formatter
{
public:
virtual ~NumpyFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
class MatlabFormatter : public FormatterBase
{
static const char* numpyTypes[] =
public:
cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
{
"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()] << "')";
}
char braces[5] = {'\0', '\0', ';', '\0', '\0'};
return new FormattedImpl("[", "]", mtx, braces,
mtx.cols == 1 || !multiline, mtx.depth() == CV_64F ? prec64f : prec32f );
}
};
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
class PythonFormatter : public FormatterBase
{
writeElems(out, data, nelems, type, '[');
}
};
public:
cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
{
char braces[5] = {'[', ']', '\0', '[', ']'};
if (mtx.cols == 1)
braces[0] = braces[1] = '\0';
return new FormattedImpl("[", "]", mtx, braces,
mtx.cols*mtx.channels() == 1 || !multiline, mtx.depth() == CV_64F ? prec64f : prec32f );
}
};
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
class NumpyFormatter : public FormatterBase
{
writeElems(out, data, nelems, type, ' ');
}
};
public:
cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
{
static const char* numpyTypes[] =
{
"uint8", "int8", "uint16", "int16", "int32", "float32", "float64", "uint64"
};
char braces[5] = {'[', ']', '\0', '[', ']'};
if (mtx.cols == 1)
braces[0] = braces[1] = '\0';
return new FormattedImpl("array([", cv::format("], type='%s')", numpyTypes[mtx.depth()]), mtx, braces,
mtx.cols*mtx.channels() == 1 || !multiline, mtx.depth() == CV_64F ? prec64f : prec32f );
}
};
class CFormatter : public Formatter
{
public:
virtual ~CFormatter() {}
void write(std::ostream& out, const Mat& m, const int*, int) const
class CSVFormatter : public FormatterBase
{
out << "{";
writeMat(out, m, ',', ' ', m.cols==1);
out << "}";
}
public:
void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
{
char braces[5] = {'\0', '\0', '\0', '\0', '\0'};
return new FormattedImpl(cv::String(), mtx.rows > 1 ? cv::String("\n") : cv::String(), mtx, braces,
mtx.cols*mtx.channels() == 1 || !multiline, mtx.depth() == CV_64F ? prec64f : prec32f );
}
};
class CFormatter : public FormatterBase
{
writeElems(out, data, nelems, type, ' ');
}
};
public:
cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
{
char braces[5] = {'\0', '\0', ',', '\0', '\0'};
return new FormattedImpl("{", "}", mtx, braces,
mtx.cols == 1 || !multiline, mtx.depth() == CV_64F ? prec64f : prec32f );
}
};
static MatlabFormatter matlabFormatter;
static PythonFormatter pythonFormatter;
static NumpyFormatter numpyFormatter;
static CSVFormatter csvFormatter;
static CFormatter cFormatter;
} // namespace
static const Formatter* g_defaultFormatter0 = &matlabFormatter;
static const Formatter* g_defaultFormatter = &matlabFormatter;
static 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 std::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)
namespace cv
{
mtx = _m;
fmt = _fmt ? _fmt : Formatter::get();
Formatted::~Formatted() {}
Formatter::~Formatter() {}
if( _params )
Ptr<Formatter> Formatter::get(int fmt)
{
int i, maxParams = 100;
for(i = 0; i < maxParams && _params[i] != 0; i+=2)
;
std::copy(_params, _params + i, back_inserter(params));
switch(fmt)
{
case FMT_MATLAB:
return new MatlabFormatter();
case FMT_CSV:
return new CSVFormatter();
case FMT_PYTHON:
return new PythonFormatter();
case FMT_NUMPY:
return new NumpyFormatter();
case FMT_C:
return new CFormatter();
}
return new MatlabFormatter();
}
}
}
} // cv

1
modules/core/test/test_io.cpp
Unescape View File

@ -378,6 +378,7 @@ protected:
TEST(Core_InputOutput, write_read_consistency) { Core_IOTest test; test.safe_run(); }
extern void testFormatter();
class CV_MiscIOTest : public cvtest::BaseTest
{

4
modules/highgui/src/window_gtk.cpp
Unescape View File

@ -1501,8 +1501,8 @@ static gboolean icvOnMouse( GtkWidget *widget, GdkEvent *event, gpointer user_da
{
// TODO move this logic to CvImageWidget
CvWindow* window = (CvWindow*)user_data;
CvPoint2D32f pt32f = {-1., -1.};
CvPoint pt = {-1,-1};
CvPoint2D32f pt32f(-1., -1.);
CvPoint pt(-1,-1);
int cv_event = -1, state = 0;
CvImageWidget * image_widget = CV_IMAGE_WIDGET( widget );

12
samples/cpp/cout_mat.cpp
Unescape View File

@ -30,16 +30,16 @@ int main(int,char**)
help();
Mat I = Mat::eye(4, 4, CV_64F);
I.at<double>(1,1) = CV_PI;
cout << "I = " << I << ";" << endl;
cout << "I = \n" << I << ";" << endl << endl;
Mat r = Mat(10, 3, CV_8UC3);
randu(r, Scalar::all(0), Scalar::all(255));
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;
cout << "r (default) = \n" << r << ";" << endl << endl;
cout << "r (python) = \n" << format(r, Formatter::FMT_PYTHON) << ";" << endl << endl;
cout << "r (numpy) = \n" << format(r, Formatter::FMT_NUMPY) << ";" << endl << endl;
cout << "r (csv) = \n" << format(r, Formatter::FMT_CSV) << ";" << endl << endl;
cout << "r (c) = \n" << format(r, Formatter::FMT_C) << ";" << endl << endl;
Point2f p(5, 1);
cout << "p = " << p << ";" << endl;

8
samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
Unescape View File

@ -59,10 +59,10 @@ int main(int,char**)
// Demonstrate the output formating options
cout << "R (default) = " << endl << R << endl << endl;
cout << "R (python) = " << endl << format(R,"python") << endl << endl;
cout << "R (numpy) = " << endl << format(R,"numpy" ) << endl << endl;
cout << "R (csv) = " << endl << format(R,"csv" ) << endl << endl;
cout << "R (c) = " << endl << format(R,"C" ) << endl << endl;
cout << "R (python) = " << endl << format(R, Formatter::FMT_PYTHON) << endl << endl;
cout << "R (numpy) = " << endl << format(R, Formatter::FMT_NUMPY ) << endl << endl;
cout << "R (csv) = " << endl << format(R, Formatter::FMT_CSV ) << endl << endl;
cout << "R (c) = " << endl << format(R, Formatter::FMT_C ) << endl << endl;
Point2f P(5, 1);
cout << "Point (2D) = " << P << endl << endl;

Write Preview
Loading…
Cancel
Save