Rewrite Mat formatting without std streams

modules/core/include/opencv2/core/operations.hpp

@@ -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

modules/core/include/opencv2/core/traits.hpp

@@ -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__

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 <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)
+        int state;
+        int row;
+        int col;
+        int cn;
+
+        cv::String prologue;
+        cv::String epilogue;
+        char braces[5];
+
+        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; }
+
+    public:
+
+        FormattedImpl(cv::String pl, cv::String el, cv::Mat m, char br[5], bool sLine, int precision)
         {
-        if(cn == 1)
+            prologue = pl;
+            epilogue = el;
+            mtx = m;
+            mcn = m.channels();
+            memcpy(braces, br, 5);
+            state = STATE_PROLOGUE;
+            singleLine = sLine;
+
+            if (precision < 0)
             {
-            out << (_WTp)data[i] << (i+1 < nelems ? ", " : "");
-            continue;
+                floatFormat[0] = '%';
+                floatFormat[1] = 'a';
+                floatFormat[2] = 0;
             }
-        out << obrace;
-        for(int j = 0; j < cn; j++)
-            out << (_WTp)data[i + j] << (j+1 < cn ? ", " : "");
-        out << cbrace << (i+cn < nelems ? ", " : "");
+            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;
+            }
+        }
 
-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))
+        void reset()
         {
-        nelems *= cn;
-        cn = 1;
+            state = STATE_PROLOGUE;
         }
+
+        const char* next()
+        {
+            switch(state)
+            {
+                case STATE_PROLOGUE:
+                    row = 0;
+                    if (mtx.empty())
+                        state = STATE_EPILOGUE;
                     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)
+                        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;
                     {
-        std::streamsize pp = out.precision();
-        out.precision(8);
-        writeElems(out, (const float*)data, nelems, cn, brace, cbrace);
-        out.precision(pp);
+                        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;
                     }
-    else if(depth == CV_64F)
+                    return buf;
+                case STATE_ROW_CLOSE:
+                    state = STATE_LINE_SEPARATOR;
+                    ++row;
+                    if (braces[BRACE_ROW_CLOSE])
                     {
-        std::streamsize pp = out.precision();
-        out.precision(16);
-        writeElems(out, (const double*)data, nelems, cn, brace, cbrace);
-        out.precision(pp);
+                        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
-        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++ )
+                        state = STATE_CN_SEPARATOR;
+                    if (mcn > 1 && braces[BRACE_CN_CLOSE])
                     {
-        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)
+                        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)
                     {
-            if(rowsep)
-                out << rowsep << (singleLine ? " " : "");
-            if(!singleLine)
-                out << "\n  ";
+                        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
+        void set32fPrecision(int p)
         {
-        writeElems(out, data, nelems, type, ' ');
+            prec32f = p;
         }
-};
 
-class PythonFormatter : public Formatter
-{
-public:
-    virtual ~PythonFormatter() {}
-    void write(std::ostream& out, const Mat& m, const int*, int) const
+        void set64fPrecision(int p)
         {
-        out << "[";
-        writeMat(out, m, m.cols > 1 ? '[' : ' ', '[', m.cols*m.channels() == 1);
-        out << "]";
+            prec64f = p;
         }
 
-    void write(std::ostream& out, const void* data, int nelems, int type, const int*, int) const
+        void setMultiline(bool ml)
         {
-        writeElems(out, data, nelems, type, '[');
+            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[] =
-        {
-            "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()] << "')";
-    }
+    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
         {
-        writeElems(out, data, nelems, type, '[');
+            char braces[5] = {'\0', '\0', ';', '\0', '\0'};
+            return new FormattedImpl("[", "]", mtx, braces,
+                mtx.cols == 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
+    class PythonFormatter : public FormatterBase
     {
-        writeMat(out, m, ' ', ' ', m.cols*m.channels() == 1);
-        if(m.rows > 1)
-            out << "\n";
-    }
+    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
         {
-        writeElems(out, data, nelems, type, ' ');
+            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 NumpyFormatter : public FormatterBase
+    {
+    public:
 
-class CFormatter : public Formatter
-{
-public:
-    virtual ~CFormatter() {}
-    void write(std::ostream& out, const Mat& m, const int*, int) const
+        cv::Ptr<cv::Formatted> format(const cv::Mat& mtx) const
         {
-        out << "{";
-        writeMat(out, m, ',', ' ', m.cols==1);
-        out << "}";
+            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 CSVFormatter : public FormatterBase
+    {
+    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
         {
-        writeElems(out, data, nelems, type, ' ');
+            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
+    {
+    public:
 
-static MatlabFormatter matlabFormatter;
-static PythonFormatter pythonFormatter;
-static NumpyFormatter numpyFormatter;
-static CSVFormatter csvFormatter;
-static CFormatter cFormatter;
+        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 const Formatter* g_defaultFormatter0 = &matlabFormatter;
-static const Formatter* g_defaultFormatter = &matlabFormatter;
+} // namespace
 
-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

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
 {

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 );
 

samples/cpp/cout_mat.cpp

@@ -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;

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;