wheeldetect/molunCar/cvmatutils.cpp

#include "cvmatutils.h"
#include <list>
#include <iostream>

using std::list;
using std::iostream;

cv::Mat getTranslateMatrix2D(float dx, float dy)
{
    Mat ret(3, 2, CV_32FC1);
    ret.setTo(0);
    float* p = (float*)ret.data;
    p[0] = 1.0;
    p[2] = dx;
    p[4] = 1.0;
    p[5] = dy;

    return ret;
}

void cutMargin(Mat& img, int w)
{
    Rect r(w, w, img.cols - 2 * w, img.rows - 2 * w);
    img = Mat(img, r);
}

cv::Mat duplicateChannels(const Mat& mat, int n)
{
    assert(mat.channels() == 1);

    vector<Mat> matVec(n, mat);

    Mat ret;
    merge(matVec, ret);

    return ret;
}

cv::Scalar sum(const Mat& mat, const Mat& mask)
{
//     double minVal, maxVal;
//     minMaxIdx(mask, &minVal, &maxVal);
//     mask /= maxVal;
    Mat mask3ch = duplicateChannels(mask, 3);
    Mat maskedMat = mask3ch & mat;
    return sum(maskedMat);
}

string toStr(const Mat& m)
{
    stringstream ss;
    switch (m.type())
    {
    case CV_8UC1:
        for (int i = 0; i < m.rows; ++i)
        {
            uchar* pRowData = m.row(i).data;
            for (int j = 0; j < m.cols; ++j)
            {
                ss << (int)pRowData[j] << " ";
            }
            ss << "\n";
        }
        break;
    case CV_32FC1:
        for (int i = 0; i < m.rows; ++i)
        {
            float* pRowData = (float*)m.row(i).data;
            for (int j = 0; j < m.cols; ++j)
            {
                ss << (float)pRowData[j] << " ";
            }
            ss << "\n";
        }
        break;
    case CV_8UC4:
        for (int i = 0; i < m.rows; ++i)
        {
            uchar* pRowData = m.row(i).data;
            for (int j = 0; j < m.cols * 4; ++j)
            {
                ss << (int)pRowData[j] << " ";
            }
            ss << "\n";
        }
        break;
    case CV_8UC3:
        for (int i = 0; i < m.rows; ++i)
        {
            uchar* pRowData = m.row(i).data;
            for (int j = 0; j < m.cols * 3; ++j)
            {
                ss << (int)pRowData[j] << " ";
            }
            ss << "\n";
        }
        break;
    }

    return ss.str();
}

cv::Mat fromStr(const string& str, int rows, int cols, int type)
{
    Mat ret;
    stringstream ss(str);
    int count = 0;
    switch (type)
    {
    case CV_8UC1:
        ret.create(rows, cols, CV_8UC1);
        for (int i = 0; i < rows; ++i)
        {
            uchar* pRowData = ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                int v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    case CV_32FC1:
        ret.create(rows, cols, CV_32FC1);
        for (int i = 0; i < rows; ++i)
        {
            float* pRowData = (float*)ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                float v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    case CV_32FC3:
        ret.create(rows, cols / 3, CV_32FC3);
        for (int i = 0; i < rows; ++i)
        {
            float* pRowData = (float*)ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                float v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    case CV_32FC4:
        ret.create(rows, cols / 4, CV_32FC4);
        for (int i = 0; i < rows; ++i)
        {
            float* pRowData = (float*)ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                float v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    case CV_8UC4:
        ret.create(rows, cols / 4, CV_8UC4);
        for (int i = 0; i < rows; ++i)
        {
            uchar* pRowData = ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                int v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    case CV_8UC3:
        ret.create(rows, cols / 3, CV_8UC3);
        for (int i = 0; i < rows; ++i)
        {
            uchar* pRowData = ret.row(i).data;
            for (int j = 0; j < cols; ++j)
            {
                if (ss.eof())
                {
                    return Mat();
                }
                int v;
                ss >> v;
                (*pRowData++) = v;
            }
        }
        break;
    default:
        return Mat();
        break;
    }
    return ret;
}