From c979de1eed8e75a5d38c2976ab6d14de0e5bf971 Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Tue, 2 Apr 2013 15:18:17 +0400 Subject: [PATCH] Rewrite Mat formatting without std streams --- modules/core/include/opencv2/core/operations.hpp | 104 ++--- modules/core/include/opencv2/core/traits.hpp | 45 ++ modules/core/src/out.cpp | 487 +++++++++++---------- modules/core/test/test_io.cpp | 1 + modules/highgui/src/window_gtk.cpp | 4 +- samples/cpp/cout_mat.cpp | 12 +- .../mat_the_basic_image_container.cpp | 8 +- 7 files changed, 365 insertions(+), 296 deletions(-) diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp index 40fe32b..398fd85 100644 --- a/modules/core/include/opencv2/core/operations.hpp +++ b/modules/core/include/opencv2/core/operations.hpp @@ -400,96 +400,80 @@ template 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& params); - Formatted(const Mat& m, const Formatter* fmt, - const int* params=0); - Mat mtx; - const Formatter* fmt; - std::vector 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& params=std::vector()) -{ - return Formatted(mtx, Formatter::get(fmt), params); -} + virtual ~Formatter(); -template static inline Formatted format(const std::vector >& vec, - const char* fmt, const std::vector& params=std::vector()) -{ - return Formatted(Mat(vec), Formatter::get(fmt), params); -} + virtual Ptr 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 static inline Formatted format(const std::vector >& vec, - const char* fmt, const std::vector& params=std::vector()) + static Ptr get(int fmt = FMT_DEFAULT); + +}; + +static inline +Ptr 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 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 static inline std::ostream& operator << (std::ostream& out, - const std::vector >& vec) +template static inline +std::ostream& operator << (std::ostream& out, const std::vector >& vec) { - Formatter::get()->write(out, Mat(vec)); - return out; + return out << Formatter::get()->format(Mat(vec)); } -template static inline std::ostream& operator << (std::ostream& out, - const std::vector >& vec) +template static inline +std::ostream& operator << (std::ostream& out, const std::vector >& vec) { - Formatter::get()->write(out, Mat(vec)); - return out; + return out << Formatter::get()->format(Mat(vec)); } /** Writes a Matx to an output stream. */ -template inline std::ostream& operator<<(std::ostream& out, const Matx<_Tp, m, n>& matx) +template 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 diff --git a/modules/core/include/opencv2/core/traits.hpp b/modules/core/include/opencv2/core/traits.hpp index de43765..642f513 100644 --- a/modules/core/include/opencv2/core/traits.hpp +++ b/modules/core/include/opencv2/core/traits.hpp @@ -227,6 +227,51 @@ public: }; }; + +template class TypeDepth {}; + +template<> class TypeDepth +{ + enum { depth = CV_8U }; + typedef uchar value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_8S }; + typedef schar value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_16U }; + typedef ushort value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_16S }; + typedef short value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_32S }; + typedef int value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_32F }; + typedef float value_type; +}; + +template<> class TypeDepth +{ + enum { depth = CV_64F }; + typedef double value_type; +}; + } // cv #endif // __OPENCV_CORE_TRAITS_HPP__ diff --git a/modules/core/src/out.cpp b/modules/core/src/out.cpp index 5ceee61..4bfd136 100644 --- a/modules/core/src/out.cpp +++ b/modules/core/src/out.cpp @@ -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 -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 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(row, col)[cn]); } + void valueToStr8s() { sprintf(buf, "%3d", (int)mtx.ptr(row, col)[cn]); } + void valueToStr16u() { sprintf(buf, "%d", (int)mtx.ptr(row, col)[cn]); } + void valueToStr16s() { sprintf(buf, "%d", (int)mtx.ptr(row, col)[cn]); } + void valueToStr32s() { sprintf(buf, "%d", mtx.ptr(row, col)[cn]); } + void valueToStr32f() { sprintf(buf, floatFormat, mtx.ptr(row, col)[cn]); } + void valueToStr64f() { sprintf(buf, floatFormat, mtx.ptr(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 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 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 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 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 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& _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::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 diff --git a/modules/core/test/test_io.cpp b/modules/core/test/test_io.cpp index c574d51..55683ec 100644 --- a/modules/core/test/test_io.cpp +++ b/modules/core/test/test_io.cpp @@ -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 { diff --git a/modules/highgui/src/window_gtk.cpp b/modules/highgui/src/window_gtk.cpp index 3ee3d0c..82a69b6 100644 --- a/modules/highgui/src/window_gtk.cpp +++ b/modules/highgui/src/window_gtk.cpp @@ -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 ); diff --git a/samples/cpp/cout_mat.cpp b/samples/cpp/cout_mat.cpp index 936a6ce..0ef94db 100644 --- a/samples/cpp/cout_mat.cpp +++ b/samples/cpp/cout_mat.cpp @@ -30,16 +30,16 @@ int main(int,char**) help(); Mat I = Mat::eye(4, 4, CV_64F); I.at(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; diff --git a/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp index 4f26f05..9c51ec8 100644 --- a/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp +++ b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp @@ -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; -- 2.7.4