Пример #1
0
int UMat::checkVector(int _elemChannels, int _depth, bool _requireContinuous) const
{
    return (depth() == _depth || _depth <= 0) &&
        (isContinuous() || !_requireContinuous) &&
        ((dims == 2 && (((rows == 1 || cols == 1) && channels() == _elemChannels) ||
                        (cols == _elemChannels && channels() == 1))) ||
        (dims == 3 && channels() == 1 && size.p[2] == _elemChannels && (size.p[0] == 1 || size.p[1] == 1) &&
         (isContinuous() || step.p[1] == step.p[2]*size.p[2])))
    ? (int)(total()*channels()/_elemChannels) : -1;
}
Пример #2
0
void Parameter::setValue(float val, int chan)
{
    
    std::cout << "Setting value of " << chan << " to " << val << std::endl;
    
	if (isBoolean())
	{
		if (val > 0.0f)
			values.set(chan, true);
		else
			values.set(chan, false);
	} 
	else if (isContinuous()) {

		if (val < (float) possibleValues[0])
		{
			values.set(chan, possibleValues[0]);
		} else if (val > (float) possibleValues[1]) {
			values.set(chan, possibleValues[1]);
		} else {
			values.set(chan, val);
		}

	} else {
		//int index = (int) val;

		//if (index >= 0 && index < possibleValues.size())
		//{
			values.set(chan, val);
		//}

	}

}
Пример #3
0
UMat UMat::reshape(int new_cn, int new_rows) const
{
    int cn = channels();
    UMat hdr = *this;

    if( dims > 2 && new_rows == 0 && new_cn != 0 && size[dims-1]*cn % new_cn == 0 )
    {
        hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn-1) << CV_CN_SHIFT);
        hdr.step[dims-1] = CV_ELEM_SIZE(hdr.flags);
        hdr.size[dims-1] = hdr.size[dims-1]*cn / new_cn;
        return hdr;
    }

    CV_Assert( dims <= 2 );

    if( new_cn == 0 )
        new_cn = cn;

    int total_width = cols * cn;

    if( (new_cn > total_width || total_width % new_cn != 0) && new_rows == 0 )
        new_rows = rows * total_width / new_cn;

    if( new_rows != 0 && new_rows != rows )
    {
        int total_size = total_width * rows;
        if( !isContinuous() )
            CV_Error( CV_BadStep,
            "The matrix is not continuous, thus its number of rows can not be changed" );

        if( (unsigned)new_rows > (unsigned)total_size )
            CV_Error( CV_StsOutOfRange, "Bad new number of rows" );

        total_width = total_size / new_rows;

        if( total_width * new_rows != total_size )
            CV_Error( CV_StsBadArg, "The total number of matrix elements "
                                    "is not divisible by the new number of rows" );

        hdr.rows = new_rows;
        hdr.step[0] = total_width * elemSize1();
    }

    int new_width = total_width / new_cn;

    if( new_width * new_cn != total_width )
        CV_Error( CV_BadNumChannels,
        "The total width is not divisible by the new number of channels" );

    hdr.cols = new_width;
    hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn-1) << CV_CN_SHIFT);
    hdr.step[1] = CV_ELEM_SIZE(hdr.flags);
    return hdr;
}
Пример #4
0
UMat UMat::reshape(int _cn, int _newndims, const int* _newsz) const
{
    if(_newndims == dims)
    {
        if(_newsz == 0)
            return reshape(_cn);
        if(_newndims == 2)
            return reshape(_cn, _newsz[0]);
    }

    if (isContinuous())
    {
        CV_Assert(_cn >= 0 && _newndims > 0 && _newndims <= CV_MAX_DIM && _newsz);

        if (_cn == 0)
            _cn = this->channels();
        else
            CV_Assert(_cn <= CV_CN_MAX);

        size_t total_elem1_ref = this->total() * this->channels();
        size_t total_elem1 = _cn;

        AutoBuffer<int, 4> newsz_buf( (size_t)_newndims );

        for (int i = 0; i < _newndims; i++)
        {
            CV_Assert(_newsz[i] >= 0);

            if (_newsz[i] > 0)
                newsz_buf[i] = _newsz[i];
            else if (i < dims)
                newsz_buf[i] = this->size[i];
            else
                CV_Error(CV_StsOutOfRange, "Copy dimension (which has zero size) is not present in source matrix");

            total_elem1 *= (size_t)newsz_buf[i];
        }

        if (total_elem1 != total_elem1_ref)
            CV_Error(CV_StsUnmatchedSizes, "Requested and source matrices have different count of elements");

        UMat hdr = *this;
        hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((_cn-1) << CV_CN_SHIFT);
        setSize(hdr, _newndims, (int*)newsz_buf, NULL, true);

        return hdr;
    }

    CV_Error(CV_StsNotImplemented, "Reshaping of n-dimensional non-continuous matrices is not supported yet");
    // TBD
    return UMat();
}
Пример #5
0
Matrix * Matrix::alphaBeta(double alpha, double beta) {
	if (isContinuous()) {
		int end = rows * cols * channels();
		uchar *data = ptr<uchar>(0);

		for (int i = 0; i < end; ++i) {
			*data = cv::saturate_cast<uchar>(alpha * (*data) + beta);
			data++;
		}
	} else {
		std::cerr << "Make alpha beta for non continous Mats!" << std::endl;
		std::exit(EXIT_FAILURE);
	}

	return this;
}
Пример #6
0
Mat& Mat::operator = (const Scalar& s)
{
    Size sz = size();
    uchar* dst = data;

    sz.width *= (int)elemSize();
    if( isContinuous() )
    {
        sz.width *= sz.height;
        sz.height = 1;
    }
    
    if( s[0] == 0 && s[1] == 0 && s[2] == 0 && s[3] == 0 )
    {
        for( ; sz.height--; dst += step )
            memset( dst, 0, sz.width );
    }
    else
    {
        int t = type(), esz1 = (int)elemSize1();
        double scalar[12];
        scalarToRawData(s, scalar, t, 12);
        int copy_len = 12*esz1;
        uchar* dst_limit = dst + sz.width;
        
        if( sz.height-- )
        {
            while( dst + copy_len <= dst_limit )
            {
                memcpy( dst, scalar, copy_len );
                dst += copy_len;
            }
            memcpy( dst, scalar, dst_limit - dst );
        }

        if( sz.height )
        {
            dst = dst_limit - sz.width + step;
            for( ; sz.height--; dst += step )
                memcpy( dst, data, sz.width );
        }
    }
    return *this;
}
Пример #7
0
cv::Mat loadThumbnails(const std::string& path)
{
    std::vector<fs::path> files;
    for (fs::directory_iterator it{ fs::path(path) }, end; it != end; ++it) {
        if (it->path().extension() == ".png" || it->path().extension() == ".jpg") {
            files.push_back(it->path());
        }
    }

    auto frameCount = files.size();
    auto w = 16;
    auto h = 16;
    auto n = frameCount * (w*h);

    std::cout << "Allocating memory... " << n * 3 * sizeof(float) / 1024 / 1024 << " MB\n";
    cv::Mat Z(n, 3, CV_32F);
    auto Zframe = 0;

    std::cout << "Reading frames...\n";
    auto frameIdx = 0;
    for (auto f : files) {
        std::cout << "  " << frameIdx << "/" << frameCount << "\n";

        auto frame = cv::imread(f.string());
        cv::resize(frame, frame, cv::Size(w, h));

        assert(frame.isContinuous());

        for (int i = 0; i < frame.size().height; ++i) {
            const cv::Vec3b* row = frame.ptr<cv::Vec3b>(i);
            for (int j = 0; j < frame.size().width; ++j) {
                cv::Vec3b v;
                convert(row[j], v, CV_BGR2Lab);
                Z.at<float>(Zframe*w*h + i*w + j, 0) = v[0];
                Z.at<float>(Zframe*w*h + i*w + j, 1) = v[1];
                Z.at<float>(Zframe*w*h + i*w + j, 2) = v[2];
            }
        }
        ++frameIdx;
        ++Zframe;
    }

    return Z;
}
Пример #8
0
/* dst = src */
void Mat::copyTo( Mat& dst ) const
{
    if( data == dst.data )
        return;

    dst.create( rows, cols, type() );
    Size sz = size();
    const uchar* sptr = data;
    uchar* dptr = dst.data;

    sz.width *= (int)elemSize();
    if( isContinuous() && dst.isContinuous() )
    {
        sz.width *= sz.height;
        sz.height = 1;
    }

    for( ; sz.height--; sptr += step, dptr += dst.step )
        memcpy( dptr, sptr, sz.width );
}
Пример #9
0
	spn::ByteBuff Surface::extractAsContinuous(uint32_t dstFmt) const {
		auto& myformat = getFormat();
		if(dstFmt == 0)
			dstFmt = myformat.format;

		auto lk = lock();
		int w = width(),
			h = height();
		// ピクセルデータが隙間なく詰まっていて、なおかつフォーマットも同じならそのままメモリをコピー
		if(isContinuous() && dstFmt==myformat.format) {
			auto* src = reinterpret_cast<uint8_t*>(lk.getBits());
			return spn::ByteBuff(src, src + w*h*myformat.BytesPerPixel);
		}
		auto upFmt = MakeUPFormat(dstFmt);
		size_t dstSize = w * h * upFmt->BytesPerPixel;
		spn::ByteBuff dst(dstSize);
		SDLEC(Trap, SDL_ConvertPixels,
					w,h,
					myformat.format, lk.getBits(), lk.getPitch(),
					dstFmt, &dst[0], w*upFmt->BytesPerPixel);
		return dst;
	}