Example #1
0
    void blobFromProto(const caffe::BlobProto &pbBlob, cv::Mat &dstBlob)
    {
        MatShape shape;
        blobShapeFromProto(pbBlob, shape);

        dstBlob.create((int)shape.size(), &shape[0], CV_32F);
        if (pbBlob.data_size())
        {
            // Single precision floats.
            CV_Assert(pbBlob.data_size() == (int)dstBlob.total());

            CV_DbgAssert(pbBlob.GetDescriptor()->FindFieldByLowercaseName("data")->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT);
            Mat(dstBlob.dims, &dstBlob.size[0], CV_32F, (void*)pbBlob.data().data()).copyTo(dstBlob);
        }
        else
        {
            CV_Assert(pbBlob.has_raw_data());
            const std::string& raw_data = pbBlob.raw_data();
            if (pbBlob.raw_data_type() == caffe::FLOAT16)
            {
                // Half precision floats.
                CV_Assert(raw_data.size() / 2 == (int)dstBlob.total());

                Mat halfs((int)shape.size(), &shape[0], CV_16SC1, (void*)raw_data.c_str());
                convertFp16(halfs, dstBlob);
            }
            else if (pbBlob.raw_data_type() == caffe::FLOAT)
            {
                CV_Assert(raw_data.size() / 4 == (int)dstBlob.total());
                Mat((int)shape.size(), &shape[0], CV_32FC1, (void*)raw_data.c_str()).copyTo(dstBlob);
            }
            else
                CV_Error(Error::StsNotImplemented, "Unexpected blob data type");
        }
    }
Example #2
0
    void blobFromProto(const caffe::BlobProto &pbBlob, cv::Mat &dstBlob)
    {
        MatShape shape;
        blobShapeFromProto(pbBlob, shape);

        dstBlob.create((int)shape.size(), &shape[0], CV_32F);
        float *dstData = dstBlob.ptr<float>();
        if (pbBlob.data_size())
        {
            // Single precision floats.
            CV_Assert(pbBlob.data_size() == (int)dstBlob.total());

            CV_DbgAssert(pbBlob.GetDescriptor()->FindFieldByLowercaseName("data")->cpp_type() == FieldDescriptor::CPPTYPE_FLOAT);

            for (int i = 0; i < pbBlob.data_size(); i++)
                dstData[i] = pbBlob.data(i);
        }
        else
        {
            // Half precision floats.
            CV_Assert(pbBlob.raw_data_type() == caffe::FLOAT16);
            std::string raw_data = pbBlob.raw_data();

            CV_Assert(raw_data.size() / 2 == (int)dstBlob.total());

            Mat halfs((int)shape.size(), &shape[0], CV_16SC1, (void*)raw_data.c_str());
            convertFp16(halfs, dstBlob);
        }
    }
Example #3
0
    double __aruco_solve_pnp(const std::vector<cv::Point3f>& p3d, const std::vector<cv::Point2f>& p2d,
                             const cv::Mat& cam_matrix, const cv::Mat& dist, cv::Mat& r_io, cv::Mat& t_io)
    {
        assert(r_io.type() == CV_32F);
        assert(t_io.type() == CV_32F);
        assert(t_io.total() == r_io.total());
        assert(t_io.total() == 3);
        auto toSol = [](const cv::Mat& r, const cv::Mat& t) {
            typename LevMarq<T>::eVector sol(6);
            for (int i = 0; i < 3; i++)
            {
                sol(i) = r.ptr<float>(0)[i];
                sol(i + 3) = t.ptr<float>(0)[i];
            }
            return sol;
        };
        auto fromSol = [](const typename LevMarq<T>::eVector& sol, cv::Mat& r, cv::Mat& t) {
            r.create(1, 3, CV_32F);
            t.create(1, 3, CV_32F);
            for (int i = 0; i < 3; i++)
            {
                r.ptr<float>(0)[i] = sol(i);
                t.ptr<float>(0)[i] = sol(i + 3);
            }
        };

        cv::Mat Jacb;
        auto err_f = [&](const typename LevMarq<T>::eVector& sol, typename LevMarq<T>::eVector& err) {
            std::vector<cv::Point2f> p2d_rej;
            cv::Mat r, t;
            fromSol(sol, r, t);
            cv::projectPoints(p3d, r, t, cam_matrix, dist, p2d_rej, Jacb);
            err.resize(p3d.size() * 2);
            int err_idx = 0;
            for (size_t i = 0; i < p3d.size(); i++)
            {
                err(err_idx++) = p2d_rej[i].x - p2d[i].x;
                err(err_idx++) = p2d_rej[i].y - p2d[i].y;
            }
        };
        auto jac_f = [&](const typename LevMarq<T>::eVector& sol, Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& J) {
            (void)(sol);
            J.resize(p3d.size() * 2, 6);
            for (size_t i = 0; i < p3d.size() * 2; i++)
            {
                double* jacb = Jacb.ptr<double>(i);
                for (int j = 0; j < 6; j++)
                    J(i, j) = jacb[j];
            }
        };

        LevMarq<T> solver;
        solver.setParams(100, 0.01, 0.01);
        //  solver.verbose()=true;
        typename LevMarq<T>::eVector sol = toSol(r_io, t_io);
        auto err = solver.solve(sol, err_f, jac_f);

        fromSol(sol, r_io, t_io);
        return err;
    }
Example #4
0
void CameraParameters::setParams(cv::Mat cameraMatrix, cv::Mat distorsionCoeff, cv::Size size)  {
    CV_Assert(cameraMatrix.rows == 3 && cameraMatrix.cols == 3);
    CV_Assert(distorsionCoeff.total() >= 4 && distorsionCoeff.total() < 7);

    cameraMatrix.convertTo(CameraMatrix, CV_32FC1);
    distorsionCoeff.convertTo(Distorsion, CV_32FC1);
    CamSize = size;
}
Example #5
0
int Hamming::fitness(cv::Mat &A, cv::Mat &B) const
{
    cv::Mat C;

    cv::bitwise_xor(A, B, C);
    int measure = cv::countNonZero(C); //czarne pixele
    int inpNonZero = A.total() - cv::countNonZero(A); //czarne pixele wejsciowe
    int refNonZero = B.total() - cv::countNonZero(B); //czarne pixele referencyjne
    if(inpNonZero < refNonZero)
    {
        measure += (refNonZero - inpNonZero) * 10;
    }

    return measure;
}
Example #6
0
/*!
 *
 */
void CameraParameters::setParams(cv::Mat &cameraMatrix, cv::Mat &distorsionCoeff, cv::Size &size)
throw(cv::Exception)
{
  if (cameraMatrix.rows!=3 || cameraMatrix.cols!=3)
    throw cv::Exception(9000,"invalid input cameraMatrix","CameraParameters::setParams",
                        __FILE__,__LINE__);
  cameraMatrix.convertTo(_k,CV_32FC1);

  if (  distorsionCoeff.total()<4 ||  distorsionCoeff.total()>=7 )
    throw cv::Exception(9000,"invalid input distorsionCoeff","CameraParameters::setParams",
                        __FILE__,__LINE__);
  distorsionCoeff.convertTo(_distor, CV_32FC1);

  _size=size;
}
Example #7
0
void WriteToMesh::writeDisparityToMeshProcessed(cv::Mat point_cloud, cv::Mat disparity, std::string filename){
    std::ofstream plyfile(filename.c_str());
    if(!plyfile.is_open()){
        throw std::runtime_error("File not found on saveComputedPoints");
    }
    int failed_pixel = 0;
    for(int y=0; y<disparity.rows; y++)
        for(int x=0; x<disparity.cols; x++){
            if(disparity.at<uchar>(y,x)==0){
                failed_pixel++;
            }
        }
    int point_num = (int)point_cloud.total();
    plyfile << "ply" << std::endl;
    plyfile << "format ascii 1.0" << std::endl;
    plyfile << "element vertex " << point_num - failed_pixel << std::endl;
    plyfile << "property float x" << std::endl;
    plyfile << "property float y" << std::endl;
    plyfile << "property float z" << std::endl;
    plyfile << "end_header" << std::endl;

    cv::Point3f point;
    for(int y=0; y<point_cloud.rows; y++)
        for(int x=0; x<point_cloud.cols; x++){
            if(disparity.at<uchar>(y,x)==0){
                continue;
            }
            point = point_cloud.at<cv::Point3f>(y,x);
            plyfile << point.x << " " << point.y << " " << point.z << std::endl;
        }
    plyfile.close();

}
Example #8
0
std::vector<unsigned long> create_histogram(const cv::Mat& mat, int channel)
{
	assert(channel >= 0 && channel < mat.channels());
	assert(mat.depth() == CV_8U);

	return create_histogram(mat.data + channel, mat.total(), mat.channels());
}
Example #9
0
void plotHistogram(const cv::Mat& histogram, cv::Mat& canvas, const cv::Scalar& color) {
  Check("Histogram", histogram).notEmpty().hasDepth(CV_32F);
  Check("Canvas", canvas).notEmpty().hasType(CV_8UC3);

  const auto N = histogram.total();
  const auto bar_width = canvas.cols / N;
  const auto bar_height = canvas.rows / histogram.channels();
  assert(bar_width > 0);
  assert(bar_height > 0);

  double max = 0;
  cv::minMaxLoc(histogram, nullptr, &max, nullptr, nullptr);

  std::vector<cv::Mat> histogram_channels;
  cv::split(histogram, histogram_channels);

  const cv::Scalar* COLORS = histogram.channels() > 1 ? utils::colors::BGR : &color;
  for (int c = 0; c < histogram.channels(); ++c) {
    cv::Mat roi(canvas, cv::Rect(0, (histogram.channels() - 1 - c) * bar_height, N * bar_width, bar_height));
    roi.setTo(255);
    for (unsigned int b = 0; b < N; b++) {
      auto value = histogram_channels[c].at<float>(b);
      auto height = std::round(value * bar_height / max);
      if (height > 0)
        cv::rectangle(roi, cv::Point(b * bar_width, bar_height - 1),
                      cv::Point((b + 1) * bar_width - 1, bar_height - 1 - height), COLORS[c], -1);
    }
  }
}
Example #10
0
void SensorData::setUserData(const cv::Mat & userData)
{
	if(!userData.empty() && (!_userDataCompressed.empty() || !_userDataRaw.empty()))
	{
		UWARN("Cannot write new user data (%d bytes) over existing user "
			  "data (%d bytes, %d compressed). Set user data of %d to null "
			  "before setting a new one.",
			  int(userData.total()*userData.elemSize()),
			  int(_userDataRaw.total()*_userDataRaw.elemSize()),
			  _userDataCompressed.cols,
			  this->id());
		return;
	}
	_userDataRaw = cv::Mat();
	_userDataCompressed = cv::Mat();

	if(!userData.empty())
	{
		if(userData.type() == CV_8UC1) // Bytes
		{
			_userDataCompressed = userData; // assume compressed
		}
		else
		{
			_userDataRaw = userData;
			_userDataCompressed = compressData2(userData);
		}
	}
}
Example #11
0
cv::Mat compressData2(const cv::Mat & data)
{
	cv::Mat bytes;
	if(!data.empty())
	{
		uLong sourceLen = uLong(data.total())*uLong(data.elemSize());
		uLong destLen = compressBound(sourceLen);
		bytes = cv::Mat(1, destLen+3*sizeof(int), CV_8UC1);
		int errCode = compress(
						(Bytef *)bytes.data,
						&destLen,
						(const Bytef *)data.data,
						sourceLen);
		bytes = cv::Mat(bytes, cv::Rect(0,0, destLen+3*sizeof(int), 1));
		*((int*)&bytes.data[destLen]) = data.rows;
		*((int*)&bytes.data[destLen+sizeof(int)]) = data.cols;
		*((int*)&bytes.data[destLen+2*sizeof(int)]) = data.type();

		if(errCode == Z_MEM_ERROR)
		{
			UERROR("Z_MEM_ERROR : Insufficient memory.");
		}
		else if(errCode == Z_BUF_ERROR)
		{
			UERROR("Z_BUF_ERROR : The buffer dest was not large enough to hold the uncompressed data.");
		}
	}
	return bytes;
}
Example #12
0
 //
 // showPropertiesOfMat
 //
 //   ...displays all properties of specified Mat.
 //
 void showPropertiesOfMat (const cv::Mat &src_mat)
 {
   // 行数
   std::cout << "rows:" << src_mat.rows <<std::endl;
   // 列数
   std::cout << "cols:" << src_mat.cols << std::endl;
   // 次元数
   std::cout << "dims:" << src_mat.dims << std::endl;
   // サイズ(2次元の場合)
   std::cout << "size[]:" << src_mat.size().width << "," << src_mat.size().height  << "[byte]" << std::endl;
   // ビット深度ID
   std::cout << "depth (ID):" << src_mat.depth() << "(=" << CV_64F << ")" << std::endl;
   // チャンネル数
   std::cout << "channels:" << src_mat.channels() << std::endl;
   // 1要素内の1チャンネル分のサイズ [バイト単位]
   std::cout << "elemSize1 (elemSize/channels):" << src_mat.elemSize1() << "[byte]" << std::endl;
   // 要素の総数
   std::cout << "total:" << src_mat.total() << std::endl;
   // ステップ数 [バイト単位]
   std::cout << "step:" << src_mat.step << "[byte]" << std::endl;
   // 1ステップ内のチャンネル総数
   std::cout << "step1 (step/elemSize1):" << src_mat.step1()  << std::endl;
   // データは連続か?
   std::cout << "isContinuous:" << (src_mat.isContinuous()?"true":"false") << std::endl;
   // 部分行列か?
   std::cout << "isSubmatrix:" << (src_mat.isSubmatrix()?"true":"false") << std::endl;
   // データは空か?
   std::cout << "empty:" << (src_mat.empty()?"true":"false") << std::endl;
 }
Example #13
0
std::vector<unsigned char> compressData(const cv::Mat & data)
{
	std::vector<unsigned char> bytes;
	if(!data.empty())
	{
		uLong sourceLen = uLong(data.total())*uLong(data.elemSize());
		uLong destLen = compressBound(sourceLen);
		bytes.resize(destLen);
		int errCode = compress(
						(Bytef *)bytes.data(),
						&destLen,
						(const Bytef *)data.data,
						sourceLen);

		bytes.resize(destLen+3*sizeof(int));
		*((int*)&bytes[destLen]) = data.rows;
		*((int*)&bytes[destLen+sizeof(int)]) = data.cols;
		*((int*)&bytes[destLen+2*sizeof(int)]) = data.type();

		if(errCode == Z_MEM_ERROR)
		{
			UERROR("Z_MEM_ERROR : Insufficient memory.");
		}
		else if(errCode == Z_BUF_ERROR)
		{
			UERROR("Z_BUF_ERROR : The buffer dest was not large enough to hold the uncompressed data.");
		}
	}
	return bytes;
}
Example #14
0
 camera_packet_t(cv::Mat mat):camera_packet_t(){
     rows=mat.rows;
     cols=mat.cols;
     data=mat.data;
     size = (unsigned int) (mat.total() * mat.elemSize());
     isMat = true;
 }
Example #15
0
WarpCost::WarpCost(const Warper& warper,
                   const cv::Mat& J,
                   const cv::Mat& I,
                   const cv::Mat& dIdx,
                   const cv::Mat& dIdy,
                   const cv::Mat& mask,
                   int interpolation,
                   bool check_condition,
                   double max_condition)
    : warper_(&warper),
      J_(&J),
      I_(&I),
      dIdx_(&dIdx),
      dIdy_(&dIdy),
      mask_(&mask),
      interpolation_(interpolation),
      check_condition_(check_condition),
      max_condition_(max_condition) {
  // Check that we have a square patch.
  CHECK(J.rows == J.cols);
  // Check that mask is correct size.
  CHECK(mask.size() == J.size());

  // Set the number of inputs (configure as a single block).
  mutable_parameter_block_sizes()->push_back(warper_->numParams());

  // Set the number of outputs.
  set_num_residuals(J.total());
}
Example #16
0
cv::Mat MedianFilter::process_frame(const cv::Mat &frame)
{
    // Get grayscale image to do sorting with
    cv::Mat gray_frame;
    cv::cvtColor(frame, gray_frame, cv::COLOR_BGR2GRAY);

    // Initialize the filter if we haven't yet
    if ( ! is_init )
        init_median_lists(frame.total());

    assert( median_lists.size() == frame.total() );

    // Init iterators
    cv::MatConstIterator_<cv::Vec3b> bgr_it  = frame.begin<cv::Vec3b>(),
                                     bgr_end = frame.end  <cv::Vec3b>();

    cv::MatConstIterator_<uchar>     gray_it = gray_frame.begin<uchar>();

    auto med_it = median_lists.begin();

    // Matrix to stuff the "current frame" into.
    cv::Mat dst(frame.rows, frame.cols, CV_8UC3);
    cv::MatIterator_<cv::Vec3b> dst_it = dst.begin<cv::Vec3b>();

    // Iterate through all pixels in each image together
    for ( ; bgr_it != bgr_end; bgr_it++, gray_it++, dst_it++, med_it++)
    {
        Pixel pixel(*bgr_it, *gray_it);

        // NOTE: because quickselect partially sorts, we're not really
        // getting rid of the min/max values, but this should be fine
        if (pop_front)
            (*med_it)[0] = pixel;
        else
            (*med_it)[filter_length-1] = pixel;

        int med_idx = (*med_it).size()/2;

        std::nth_element((*med_it).begin(), (*med_it).begin()+med_idx, (*med_it).end());

        *dst_it = (*med_it)[med_idx].color;
    }

    pop_front = ! pop_front;

    return dst;
}
Example #17
0
bool write_bgr_image(const cv::Mat& output_image, const std::string& output_filename)
{
    std::cout << "Output Image: name=" << output_filename
            << ", width=" << output_image.cols << ", height=" << output_image.rows
            << ", channels=" << output_image.channels() << ", total=" << output_image.total()
            << std::endl;
    return cv::imwrite(output_filename, output_image);
}
Example #18
0
void CameraParameters::setParams(cv::Mat cameraMatrix,cv::Mat distorsionCoeff,cv::Size size)
{
    if (cameraMatrix.rows!=3 || cameraMatrix.cols!=3)
        throw cv::Exception(9000,"invalid input cameraMatrix","CameraParameters::setParams",__FILE__,__LINE__);
    cameraMatrix.convertTo(CameraMatrix,CV_32FC1);
    if (  distorsionCoeff.total()<4 ||  distorsionCoeff.total()>5 )
        throw cv::Exception(9000,"invalid input distorsionCoeff","CameraParameters::setParams",__FILE__,__LINE__);
    cv::Mat auxD;
    distorsionCoeff.convertTo( auxD,CV_32FC1);
    //now, get only the 4 first elements

    Distorsion.create(1,4,CV_32FC1);
    for (int i=0;i<4;i++)
        Distorsion.ptr<float>(0)[i]=auxD.ptr<float>(0)[i];

    CamSize=size;
}
void printImageData(const cv::Mat& input, std::string description){
  std::cout << description << std::endl;
  std::cout << "matrix type: " << input.type() << std::endl;
  std::cout << "matrix depth: " << input.depth() << std::endl;
  std::cout << "channels: " << input.channels() << std::endl;
  std::cout << "size: " << input.size() << std::endl;
  std::cout << "total elem: " << input.total() << std::endl;
  std::cout << std::endl;
}
Example #20
0
void CameraParameters::setParams(cv::Mat cameraMatrix,cv::Mat distorsionCoeff,cv::Size size)
{
    if (cameraMatrix.rows!=3 || cameraMatrix.cols!=3)
        return;
    cameraMatrix.convertTo(CameraMatrix,CV_32FC1);
    if (  distorsionCoeff.total()<4 ||  distorsionCoeff.total()>=7 )
        return;
    cv::Mat auxD;

    distorsionCoeff.convertTo( Distorsion,CV_32FC1);

//     Distorsion.create(1,4,CV_32FC1);
//     for (int i=0;i<4;i++)
//         Distorsion.ptr<float>(0)[i]=auxD.ptr<float>(0)[i];

    CamSize=size;

}
Example #21
0
cv::Mat plotHistogram(const cv::Mat& histogram, unsigned int bar_width, unsigned int height, const cv::Scalar& color) {
  assert(bar_width > 0);
  assert(height > 0);

  cv::Mat canvas(height * histogram.channels(), bar_width * histogram.total(), CV_8UC3);
  canvas.setTo(0);

  plotHistogram(histogram, canvas, color);
  return canvas;
}
Example #22
0
cv::Mat createMultiChannelMask(const cv::Mat& img, const cv::Mat& mask) {
    cv::Mat out(img.size(), CV_8UC4, cv::Scalar::all(0));
    for (int i = 0; i < img.total(); i++) {
        for (int j = 0; j < 3; j++)
            out.ptr<cv::Vec4b>()[i][j] = img.ptr<cv::Vec3b>()[i][j];
        if (mask.size() == img.size())
            out.ptr<cv::Vec4b>()[i][3] = mask.ptr<unsigned char>()[i];
    }
    return out;
}
Example #23
0
template <typename Tp, int cn> KDTree <Tp, cn>::
KDTree(const cv::Mat &img, const int _leafNumber, const int _zeroThresh)
    : height(img.rows), width(img.cols),
      leafNumber(_leafNumber), zeroThresh(_zeroThresh)
///////////////////////////////////////////////////
{
    int imgch = img.channels();
    CV_Assert( img.isContinuous() && imgch <= cn);

    for(size_t i = 0; i < img.total(); i++)
    {
        cv::Vec<Tp, cn> v = cv::Vec<Tp, cn>::all((Tp)0);
        for (int c = 0; c < imgch; c++)
        {
            v[c] = *((Tp*)(img.data) + i*imgch + c);
        }
        data.push_back(v);
    }

    generate_seq( std::back_inserter(idx), 0, int(data.size()) );
    std::fill_n( std::back_inserter(nodes),
        int(data.size()), cv::Point2i(0, 0) );

    std::stack <int> left, right;
    left.push( 0 );
    right.push( int(idx.size()) );

    while ( !left.empty() )
    {
        int  _left = left.top();   left.pop();
        int _right = right.top(); right.pop();

        if ( _right - _left <= leafNumber)
        {
            for (int i = _left; i < _right; ++i)
                nodes[idx[i]] = cv::Point2i(_left, _right);
            continue;
        }

        int nth = _left + (_right - _left)/2;

        int dimIdx = getMaxSpreadN(_left, _right);
        KDTreeComparator comp( this, dimIdx );

        std::nth_element(/**/
            idx.begin() +  _left,
            idx.begin() +    nth,
            idx.begin() + _right, comp
                         /**/);

          left.push(_left); right.push(nth + 1);
        left.push(nth + 1);  right.push(_right);
    }
}
//! Write cv::Mat to binary file
void writeMatBinary(std::ofstream& ofs, const cv::Mat& out_mat)
{
	if(!ofs.is_open()){
		throw new orArgException("not opened");
	}
	int type = out_mat.type();
	ofs.write((const char*)(&out_mat.rows), sizeof(int));
	ofs.write((const char*)(&out_mat.cols), sizeof(int));
	ofs.write((const char*)(&type), sizeof(int));
	ofs.write((const char*)(out_mat.data), out_mat.elemSize() * out_mat.total());
}
Example #25
0
bool Core_EigenTest::check_pairs_order(const cv::Mat& eigen_values)
{
    switch (eigen_values.type())
    {
    case CV_32FC1:
        {
            for (int i = 0; i < (int)(eigen_values.total() - 1); ++i)
                if (!(eigen_values.at<float>(i, 0) > eigen_values.at<float>(i+1, 0)))
                {
                std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
                std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl;
                std::cout << endl;
                CV_Error(CORE_EIGEN_ERROR_ORDER, MESSAGE_ERROR_ORDER);
                return false;
            }

            break;
        }

    case CV_64FC1:
        {
            for (int i = 0; i < (int)(eigen_values.total() - 1); ++i)
                if (!(eigen_values.at<double>(i, 0) > eigen_values.at<double>(i+1, 0)))
                {
                    std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
                    std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl;
                    std::cout << endl;
                    CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order.");
                    return false;
                }

            break;
        }

    default:;
    }

    return true;
}
Example #26
0
bool PointSelection::getDebugIndex(const size_t& level, cv::Mat& dbg_idx)
{
  if(debug_ && storage_.size() > level)
  {
    dbg_idx = storage_[level].debug_idx;

    return dbg_idx.total() > 0;
  }
  else
  {
    return false;
  }
}
Example #27
0
void cv::CircleDetector::Context::debug_buffer(const cv::Mat& image, cv::Mat& out)
{
  out.create(height, width, CV_8UC3);
  cv::Vec3b* out_ptr = out.ptr<cv::Vec3b>(0);
  const cv::Vec3b* im_ptr = image.ptr<cv::Vec3b>(0);
  out = cv::Scalar(128,128,128);
  for (uint i = 0; i < out.total(); i++, ++out_ptr, ++im_ptr) {
    /*if (buffer[i] == -1) *ptr = cv::Vec3b(0,0,0);
    else if (buffer[i] == -2) *ptr = cv::Vec3b(255,255,255);*/
    //else if (buffer[i] < 0) *ptr = cv::Vec3b(0, 255, 0);
    if (buffer[i] > 0) *out_ptr = cv::Vec3b(255, 0, 255);
    else *out_ptr = *im_ptr;
  }
}
//! Read cv::Mat from binary
void readMatBinary(std::ifstream& ifs, cv::Mat& in_mat)
{
	if(!ifs.is_open()){
		throw new orArgException("Not opened");
	}
	
	int rows, cols, type;
	ifs.read((char*)(&rows), sizeof(int));
	ifs.read((char*)(&cols), sizeof(int));
	ifs.read((char*)(&type), sizeof(int));

	in_mat.release();
	in_mat.create(rows, cols, type);
	ifs.read((char*)(in_mat.data), in_mat.elemSize() * in_mat.total());
}
Example #29
0
void hulo::readMatBin(std::string filename, cv::Mat& mat) {
	std::ifstream ifs(filename, std::ios::binary);
	CV_Assert(ifs.is_open());

	int rows, cols, type;
	ifs.read((char*) (&rows), sizeof(int));
	if (rows == 0) {
		return;
	}
	ifs.read((char*) (&cols), sizeof(int));
	ifs.read((char*) (&type), sizeof(int));

	mat.release();
	mat.create(rows, cols, type);
	ifs.read((char*) (mat.data), mat.elemSize() * mat.total());
}
Example #30
0
void SensorData::setUserDataRaw(const cv::Mat & userDataRaw)
{
	if(!userDataRaw.empty() && (!_userDataCompressed.empty() || !_userDataRaw.empty()))
	{
		UWARN("Cannot write new user data (%d bytes) over existing user "
			  "data (%d bytes, %d compressed). Set user data of %d to null "
			  "before setting a new one.",
			  int(userDataRaw.total()*userDataRaw.elemSize()),
			  int(_userDataRaw.total()*_userDataRaw.elemSize()),
			  _userDataCompressed.cols,
			  this->id());
		return;
	}
	_userDataRaw = userDataRaw;
	_userDataCompressed = cv::Mat();
}