/*
* Class: com_nekomeshi312_stabcam_StabCameraViewFragment
* Method: stopStabilize
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_nekomeshi312_stabcam_StabCameraViewFragment_stopStabilize
(JNIEnv *jenv, jobject jobj)
{
LOGI("stopStabilize");
gGrayPrev.release();
gGrayCur.release();
gRGBACur.release();
gAffine.release();
#ifdef USE_POC
gHann.release();
#endif
}
void load_calibration_data(const std::string &file_name, cv::Mat &intrinsics_common, cv::Mat &distortion_vector)
{
if (file_name.empty()) return;
intrinsics_common.release();
distortion_vector.release();
cv::FileStorage fs;
if(fs.open(file_name, cv::FileStorage::READ | cv::FileStorage::FORMAT_XML, "utf8")) {
fs["camera_distortion"] >> distortion_vector;
fs["camera_intrinsics"] >> intrinsics_common;
fs.release();
} else {
void CMySharkML::GetPredictionLabelandConfidence(std::vector<int> &predictLable, cv::Mat &predictConf, Data<RealVector> &predictions)
{
predictLable.clear();
predictConf.release();
std::size_t numElements = predictions.numberOfElements();
predictLable.assign(numElements, 0);
predictConf = cv::Mat(numElements, m_numLabels, CV_32F);
memset(predictConf.data, 0, sizeof(float)*numElements*m_numLabels);
for(int k = 0; k < numElements; ++k) {
predictions.element(k);
RealVector::iterator iter_p = predictions.element(k).begin(); //Predict.begin();
float maxP = *iter_p;
int L = 0;
predictConf.at<float>(k, 0) = *iter_p;
std::size_t numInputs = predictions.element(k).size(); //Predict.size();
for(int i=1; i<numInputs; ++i){
iter_p++;
predictConf.at<float>(k, i) = *iter_p;
if(*iter_p > maxP) {
maxP = *iter_p;
L = i;
}
}
predictLable[k] = L;
}
}
bool CvMongoMat::download(cv::Mat &image)
{
image.release();
if (conn_ == NULL) return false;
std::auto_ptr<mongo::DBClientCursor> cursor;
cursor = conn_->query(collection_, QUERY(key_ << BSON("$exists" << true)));
if (cursor->more() == false) {
// notiong to do...
return true;
}
mongo::BSONObj obj = cursor->next();
timestamp_ = obj["timestamp"].Long();
int len;
uchar *data = (uchar*)obj[key_].binData(len);
if (len == 0) return true;
std::vector<uchar> v(data, data+len);
image = cv::imdecode(cv::Mat(v), -1);
return true;
}
void FORB::toMat32F(const std::vector<TDescriptor> &descriptors,
cv::Mat &mat)
{
if(descriptors.empty())
{
mat.release();
return;
}
const size_t N = descriptors.size();
mat.create(N, FORB::L*8, CV_32F);
float *p = mat.ptr<float>();
for(size_t i = 0; i < N; ++i)
{
const int C = descriptors[i].cols;
const unsigned char *desc = descriptors[i].ptr<unsigned char>();
for(int j = 0; j < C; ++j, p += 8)
{
p[0] = (desc[j] & (1 << 7) ? 1 : 0);
p[1] = (desc[j] & (1 << 6) ? 1 : 0);
p[2] = (desc[j] & (1 << 5) ? 1 : 0);
p[3] = (desc[j] & (1 << 4) ? 1 : 0);
p[4] = (desc[j] & (1 << 3) ? 1 : 0);
p[5] = (desc[j] & (1 << 2) ? 1 : 0);
p[6] = (desc[j] & (1 << 1) ? 1 : 0);
p[7] = desc[j] & (1);
}
}
}
static void calculateFeaturesFromInput( cv::Mat imageData, std::vector< float >& featureVector, cv::HOGDescriptor& hog )
{
std::vector< cv::Point > locations;
hog.compute( imageData, featureVector, winStride, trainingPadding, locations );
imageData.release();
}
int VirtualCamera::loadMatrix(cv::Mat &matrix,int rows,int cols ,std::string file)
{
std:: ifstream in1;
in1.open(file.c_str());
//if(in1==NULL) //Yang
if (in1.fail())
{
std::cout<<"Error loading file "<<file.c_str()<<"\n";
return -1;
}
if(!matrix.empty())
matrix.release();
matrix=cv::Mat(rows, cols, CV_32F);
for(int i=0; i<rows; i++)
{
for(int j=0; j<cols; j++)
{
float val;
in1>>val;
Utilities::matSet2D(matrix,j,i,val);
}
}
return 1;
}
bool VideoCapture::retrieve(cv::Mat& image, int channel){
if(cam_interface.empty()){
image.release();
return false;
}
return cam_interface[0]->retrieve(image,channel);
}
PTS32 _cvtColor2BGR(PTU8* pPixels, PTS32 nWidth, PTS32 nHeight, PTImageFormatEnum eFormat, cv::Mat& bgrMat)
{
if(pPixels == NULL || nWidth < 0 || nHeight < 0) {
PTDEBUG("%s: Invalid parameters, pPixels[%p], nWidth[%d], nHeight[%d]\n", __FUNCTION__, pPixels, nWidth, nHeight);
return PT_RET_INVALIDPARAM;
}
if(eFormat != PT_IMG_BGR888 && eFormat != PT_IMG_RGBA8888 && eFormat != PT_IMG_ARGB8888 && eFormat != PT_IMG_BGRA8888) {
PTDEBUG("%s: picture format[%d], ie[%s] not supported!\n",__FUNCTION__, (int)eFormat, strImageFormat[eFormat]);
return PT_RET_INVALIDPARAM;
}
bgrMat.release();
PTU8* pBuffer = NULL;
if(eFormat == PT_IMG_ARGB8888) {
pBuffer = (PTU8*) malloc(3*nWidth*nHeight);//buffer for BGR
if(pBuffer == NULL) {
PTDEBUG("%s: no enough memory to support format[%s]\n", __FUNCTION__, strImageFormat[eFormat]);
return PT_RET_NOMEM;
}
}
switch(eFormat) {
case PT_IMG_BGR888 : {
bgrMat = cv::Mat(nHeight, nWidth, CV_8UC3, pPixels);
}
break;
case PT_IMG_RGBA8888 : {
cvtColor(cv::Mat(nHeight, nWidth, CV_8UC4, pPixels), bgrMat, CV_RGBA2BGR);
}
break;
case PT_IMG_ARGB8888 : {
const int nSrcChannel = 4;
const int nDstChannel = 3;
const int nPixels = nHeight*nWidth;
PTU8* pSrcBuffer = pPixels;
PTU8* pDstBuffer = pBuffer;
for(int i = 0; i < nPixels; i++) {
pDstBuffer[2] = pSrcBuffer[1];//R
pDstBuffer[1] = pSrcBuffer[2];//G
pDstBuffer[0] = pSrcBuffer[3];//B
pSrcBuffer += nSrcChannel;
pDstBuffer += nDstChannel;
}
bgrMat = cv::Mat(nHeight, nWidth, CV_8UC3, pBuffer);
}
break;
case PT_IMG_BGRA8888 : {
cvtColor(cv::Mat(nHeight, nWidth, CV_8UC4, pPixels), bgrMat, CV_BGRA2BGR);
}
break;
default : {
PTDEBUG("%s: picture format[%d], ie[%s] not supported!\n", __FUNCTION__, (int)eFormat, strImageFormat[eFormat]);
return PT_RET_INVALIDPARAM;
}
break;
}
return PT_RET_OK;
}
void CallBackFunc(int evnt, int x, int y, int flags, void* userdata) {
if (evnt == cv::EVENT_LBUTTONDOWN) {
mouseButtonDown = true;
targetSelected = false;
boundingRect = cv::Rect(0,0,0,0);
point1 = cv::Point(x,y);
cv::destroyWindow(targetName);
cv::destroyWindow(ColorTracker.getColorSquareWindowName());
targetImage.release();
}
if (evnt == cv::EVENT_MOUSEMOVE) {
if (x < 0) x = 0;
else if (x > image.cols) x = image.cols;
if (y < 0) y = 0;
else if (y > image.rows) y = image.rows;
point2 = cv::Point(x,y);
if (mouseButtonDown) {
boundingRect = cv::Rect(point1,point2);
}
cv::imshow(imageName,image);
}
if (evnt == cv::EVENT_LBUTTONUP) {
mouseButtonDown = false;
if (boundingRect.area() != 0) {
targetImage = image(calibratedRect(boundingRect));
cv::imshow(targetName, targetImage);
}
else {
boundingRect = cv::Rect(point1-cv::Point(5,5),point1+cv::Point(5,5));
targetImage = image(calibratedRect(boundingRect));
cv::imshow(targetName, targetImage);
}
targetSelected = true;
}
}
void FileUtils::loadDescriptorsFromZippedBin(const std::string& filename,
cv::Mat& descriptors) {
std::ifstream zippedFile;
boost::iostreams::filtering_istream is;
// Open file
zippedFile.open(filename.c_str(), std::fstream::in | std::fstream::binary);
// Check file
if (zippedFile.good() == false) {
throw std::runtime_error(
"Unable to open file [" + filename + "] for reading");
}
// Obtain uncompressed file size
zippedFile.seekg(-sizeof(int), zippedFile.end);
int fileSize = -1;
zippedFile.read((char*) &fileSize, sizeof(int));
zippedFile.seekg(0, zippedFile.beg);
try {
is.push(boost::iostreams::gzip_decompressor());
is.push(zippedFile);
// Read rows byte
int rows = -1;
is.read((char*) &rows, sizeof(int));
// Read columns byte
int cols = -1;
is.read((char*) &cols, sizeof(int));
// Read type byte
int type = -1;
is.read((char*) &type, sizeof(int));
// Compute data stream size
long dataStreamSize = fileSize - 3 * sizeof(int);
descriptors.release();
descriptors = cv::Mat();
if (type != CV_32F && type != CV_8U) {
throw std::runtime_error("Invalid descriptors type");
}
descriptors.create(rows, cols, type);
// Read data bytes
is.read((char*) descriptors.data, dataStreamSize);
} catch (const boost::iostreams::gzip_error& e) {
throw std::runtime_error(
"Got error while reading file [" + std::string(e.what()) + "]");
}
// Close file
zippedFile.close();
}
bool kfusion::OpenNISource::grab(cv::Mat& depth, cv::Mat& color)
{
Status rc = STATUS_OK;
if (impl_->has_depth)
{
rc = impl_->depthStream.readFrame(&impl_->depthFrame);
if (rc != openni::STATUS_OK)
{
sprintf (impl_->strError, "Frame grab failed: %s\n", openni::OpenNI::getExtendedError() );
REPORT_ERROR (impl_->strError);
}
const void* pDepth = impl_->depthFrame.getData();
int x = impl_->depthFrame.getWidth();
int y = impl_->depthFrame.getHeight();
cv::Mat(y, x, CV_16U, (void*)pDepth).copyTo(depth);
}
else
{
depth.release();
printf ("no depth\n");
}
if (impl_->has_image)
{
rc = impl_->colorStream.readFrame(&impl_->colorFrame);
if (rc != openni::STATUS_OK)
{
sprintf (impl_->strError, "Frame grab failed: %s\n", openni::OpenNI::getExtendedError() );
REPORT_ERROR (impl_->strError);
}
const void* pColor = impl_->colorFrame.getData();
int x = impl_->colorFrame.getWidth();
int y = impl_->colorFrame.getHeight();
cv::Mat(y, x, CV_8UC3, (void*)pColor).copyTo(color);
}
else
{
color.release();
printf ("no color\n");
}
return impl_->has_image || impl_->has_depth;
}
// Create a function which manages a clean "CTRL+C" command -> sigint command
void sigint_handler(int dummy)
{
ROS_INFO("- detect-human-face is shutting down...\n");
// Liberation de l'espace memoire
cv::destroyWindow("Initial");
cv::destroyWindow("final");
cv::destroyWindow("diffImg");
prevImg.release();
currImg.release();
cvReleaseHaarClassifierCascade(&cascade);
cvReleaseMemStorage(&storage);
ROS_INFO("\n\n... Bye bye !\n -Manu\n");
exit(EXIT_SUCCESS); // Shut down the program
}
bool DeckLinkCapture::read(cv::Mat& videoFrame)
{
if (grab())
return retrieve(videoFrame);
else {
videoFrame.release();
return false;
}
}
void spectralFiltering::getResult(cv::Mat &img)
{
if(originImg.empty())
return;
std::vector<cv::Mat> imageR(channel), imageI(channel);
#pragma omp parallel for
for(int k = 0;k < channel; k++)
{
imageR[k] = spectral[k].real.clone();
imageI[k] = spectral[k].imag.clone();
moveSpectral2Center(imageR[k]);
moveSpectral2Center(imageI[k]);
}
if(originImg.type()==CV_8UC3 && colorMode)
{
std::vector<cv::Mat> temp(channel);
#pragma omp parallel for
for(int k = 0;k < channel; k++)
{
if(GHPF)
iFFT2DHomo(imageR[k], imageI[k], temp[k], originImg.size().width, originImg.size().height);
else
iFFT2D(imageR[k], imageI[k], temp[k], originImg.size().width, originImg.size().height);
}
img.release();
cv::merge(temp, img);
}
else
{
if(GHPF)
iFFT2DHomo(imageR[0], imageI[0], img, originImg.size().width, originImg.size().height);
else
iFFT2D(imageR[0], imageI[0], img, originImg.size().width, originImg.size().height);
}
/*
if(originImg.type()==CV_8UC3 && colorMode)
{
cv::Mat temp;
iFFT2D(imageR, imageI, temp, originImg.size().width, originImg.size().height);
int j, i;
#pragma omp parallel for private(i)
for(j = 0; j < temp.rows; j++)
{
for(i = 0; i < temp.cols; i++)
{
HSV.at<cv::Vec3f>(j,i)[2] = temp.at<uchar>(j,i);
}
}
myCvtColor(HSV, img, HSV2BGR);
}
else
{
iFFT2D(imageR, imageI, img, originImg.size().width, originImg.size().height);
}*/
}
//analysis operator: action analyse; takes the phase signal and gives the sequence of coefficients (representation realm)
//from phase signal space to zernike representation
void Zernike::analyse(const cv::Mat& sig, cv::Mat& z_coeffs)
{
z_coeffs.release();
for(cv::Mat z_j : base_)
{
double l2 = cv::norm(z_j, cv::NORM_L2);
double inner_prod = z_j.dot(sig)/(l2*l2);
z_coeffs.push_back( inner_prod );
}
}
bool vm::scanner::OpenNISource::grab(cv::Mat& depth, cv::Mat& image)
{
XnStatus rc = XN_STATUS_OK;
rc = impl_->context.WaitAndUpdateAll ();
if (rc != XN_STATUS_OK)
return printf ("Read failed: %s\n", xnGetStatusString (rc)), false;
if (impl_->has_depth)
{
impl_->depth.GetMetaData (impl_->depthMD);
const XnDepthPixel* pDepth = impl_->depthMD.Data ();
int x = impl_->depthMD.FullXRes ();
int y = impl_->depthMD.FullYRes ();
cv::Mat(y, x, CV_16U, (void*)pDepth).copyTo(depth);
}
else
{
depth.release();
printf ("no depth\n");
}
if (impl_->has_image)
{
impl_->image.GetMetaData (impl_->imageMD);
const XnRGB24Pixel* pImage = impl_->imageMD.RGB24Data ();
int x = impl_->imageMD.FullXRes ();
int y = impl_->imageMD.FullYRes ();
image.create(y, x, CV_8UC3);
cv::Vec3b *dptr = image.ptr<cv::Vec3b>();
for(size_t i = 0; i < image.total(); ++i)
dptr[i] = cv::Vec3b(pImage[i].nBlue, pImage[i].nGreen, pImage[i].nRed);
}
else
{
image.release();
printf ("no image\n");
}
return impl_->has_image || impl_->has_depth;
}
void release_mat_memory()
{
background_color.release();
background_color_resize.release();
raw_color.release();
absdiff_color.release();
absdiff_gray.release();
absdiff_binary.release();
markers.release();
}
void read_heatmap(double * heatmap_array, int heatmap_index, cv::Mat& heatmap_mat)
{
heatmap_mat.release();
heatmap_mat.create(HEAT_SZ, HEAT_SZ, CV_32FC1);
for (int i = 0; i < HEAT_SZ; ++i)
{
for (int j = 0; j < HEAT_SZ; ++j)
{
heatmap_mat.at<float>(i, j) = heatmap_array[heatmap_index + i*HEAT_SZ + j];
}
}
}
bool DeckLinkCapture::retrieve(cv::Mat& videoFrame)
{
if (! deckLinkInputCallback_ || !grabbedVideoFrame_) {
videoFrame.release();
return false;
}
bool status = deckLinkVideoFrameToCvMat(grabbedVideoFrame_, videoFrame);
BOOST_LOG_TRIVIAL(info) << "Video Status: "
<< status
<< std::endl;
if (!status) {
error_ = E_FAIL;
errorString_ = "Error converting the image format.";
videoFrame.release();
return false;
}
return true;
}
void Shape::ToTransMat(cv::Mat& dstTransMat)
{
dstTransMat.release();
dstTransMat.create(m_Shape.size(), 3, LBF_MAT_TYPE);
for (int i = 0; i < dstTransMat.rows; i++)
{
dstTransMat.at<LBF_DATA>(i, 0) = m_Shape[i].x;
dstTransMat.at<LBF_DATA>(i, 1) = m_Shape[i].y;
dstTransMat.at<LBF_DATA>(i, 2) = 1;
}
return;
}
// 画像を読み込んで値を0.0f〜1.0fの範囲に変換
Waifu2x::eWaifu2xError Waifu2x::LoadMat(cv::Mat &float_image, const uint32_t* source, int width, int height)
{
float_image = cv::Mat(cv::Size(width, height), CV_MAKETYPE(CV_8U, 4));
const auto LinePixel = float_image.step1() / float_image.channels();
const auto Channel = float_image.channels();
const auto Width = float_image.size().width;
const auto Height = float_image.size().height;
const uint8_t *sptr = (const uint8_t *)source;
auto ptr = float_image.data;
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
for (int ch = 0; ch < Channel; ch++)
ptr[(i * LinePixel + j) * 4 + ch] = sptr[(i * width + j) * 4 + ch];
}
}
// RGBだからBGRに変換
/*
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
std::swap(ptr[(i * LinePixel + j) * 4 + 0], ptr[(i * LinePixel + j) * 4 + 2]);
}
*/
cv::Mat convert;
float_image.convertTo(convert, CV_32F, 1.0 / 255.0);
float_image.release();
{
// アルファチャンネル付きだったらα乗算済みにする
std::vector<cv::Mat> planes;
cv::split(convert, planes);
cv::Mat w = planes[3];
planes[0] = planes[0].mul(w);
planes[1] = planes[1].mul(w);
planes[2] = planes[2].mul(w);
cv::merge(planes, convert);
}
float_image = convert;
return eWaifu2xError_OK;
}
void LBSP::computeImpl(const cv::Mat& oImage, std::vector<cv::KeyPoint>& voKeypoints, cv::Mat& oDescriptors) const {
CV_Assert(!oImage.empty());
cv::KeyPointsFilter::runByImageBorder(voKeypoints,oImage.size(),PATCH_SIZE/2);
cv::KeyPointsFilter::runByKeypointSize(voKeypoints,std::numeric_limits<float>::epsilon());
if(voKeypoints.empty()) {
oDescriptors.release();
return;
}
if(m_bOnlyUsingAbsThreshold)
lbsp_computeImpl(oImage,m_oRefImage,voKeypoints,oDescriptors,true,m_nThreshold);
else
lbsp_computeImpl(oImage,m_oRefImage,voKeypoints,oDescriptors,true,m_fRelThreshold,m_nThreshold);
}
void FileUtils::loadDescriptorsFromBin(const std::string& filename,
cv::Mat& descriptors) {
std::ifstream is;
// Open file
is.open(filename.c_str(), std::fstream::in | std::fstream::binary);
// Check file
if (is.good() == false) {
throw std::runtime_error(
"Unable to open file [" + filename + "] for reading");
}
// Obtain uncompressed file size
is.seekg(0, is.end);
int fileSize = is.tellg();
is.seekg(0, is.beg);
// Read rows byte
int rows = -1;
is.read((char*) &rows, sizeof(int));
// Read columns byte
int cols = -1;
is.read((char*) &cols, sizeof(int));
// Read type byte
int type = -1;
is.read((char*) &type, sizeof(int));
// Check type
if (type != CV_32F && type != CV_8U) {
throw std::runtime_error("Invalid descriptors type");
}
// Compute data stream size
long dataStreamSize = fileSize - 3 * sizeof(int);
// Allocate memory to contain the data bytes
descriptors.release();
descriptors = cv::Mat();
descriptors.create(rows, cols, type);
// Read data bytes
is.read((char*) descriptors.data, dataStreamSize);
// Close file
is.close();
}
bool C920Camera::RetrieveMat(cv::Mat &image) {
IplImage* _img = this->RetrieveFrame(this->capture);
if (!_img) {
image.release();
return false;
}
if (_img->origin == IPL_ORIGIN_TL)
cv::Mat(_img).copyTo(image);
else {
cv::Mat temp(_img);
cv::flip(temp, image, 0);
}
return true;
}
ImgType copy_cvmat_to_dlib_mat(cv::Mat &input, bool release_after_copy = true)
{
static_assert(std::is_class<ImgType>::value, "ImgType should be a class");
using pixel_type = typename dlib::image_traits<ImgType>::pixel_type;
cv_image<pixel_type> cimg(input);
ImgType output;
dlib::assign_image(output, cimg);
if(release_after_copy){
input.release();
}
return output;
}
void histogram_generator_eyes::compute_histogram(cv::Mat& image, cv::Mat& histogram){
//Releasing the memory
histogram.release();
//Mat aux individual descriptor
cv::Mat aux_descriptors;
cv::Mat aux_histogram;
cv::Mat aux_histogram2;
//Aux info to compute the boxes
int aux_cols;
int aux_rows;
//Boxes
std::vector<box> boxes;
//Cropped aux image
cv::Mat cropped_image;
//getting the size of the image
aux_cols=image.cols;
aux_rows=image.rows;
//Getting the boxes
std::vector<int> binx;
std::vector<int> biny;
binx.push_back(1);
biny.push_back(1);
boxes=generateSpatialBoxes(aux_rows, aux_cols, binx , biny);
//Crop the images and extraction features
for(unsigned int j=0;j<boxes.size();j++){
cropped_image= image(cv::Range(boxes.at(j).minY, boxes.at(j).maxY), cv::Range(boxes.at(j).minX, boxes.at(j).maxX));
aux_descriptors=feature_extract->extract_dsift(cropped_image,2,4);
aux_histogram2=clustering->get_histogram(aux_descriptors);
transpose(aux_histogram2, aux_histogram2);
aux_histogram.push_back(aux_histogram2);
}
transpose(aux_histogram, aux_histogram);
histogram.push_back(aux_histogram);
aux_histogram.release();
}
//! 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());
}
void shuffleRows(const cv::Mat &matrix, cv::Mat& shuffleMatrix)
{
shuffleMatrix.release();
std::vector <int> seeds;
for (int cont = 0; cont < matrix.rows; cont++)
{
seeds.push_back(cont);
}
cv::theRNG() = cv::RNG( cv::getTickCount() );
cv::randShuffle(seeds);
for (int cont = 0; cont < matrix.rows; cont++)
{
shuffleMatrix.push_back(matrix.row(seeds[cont]));
}
}
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());
}