struct TensorArray KalmanFilter_getFields(struct KalmanFilterPtr ptr)
{
std::vector<MatT> retval(10);
retval[0] = MatT(ptr->statePre);
retval[1] = MatT(ptr->statePost);
retval[2] = MatT(ptr->transitionMatrix);
retval[3] = MatT(ptr->controlMatrix);
retval[4] = MatT(ptr->measurementMatrix);
retval[5] = MatT(ptr->processNoiseCov);
retval[6] = MatT(ptr->measurementNoiseCov);
retval[7] = MatT(ptr->errorCovPre);
retval[8] = MatT(ptr->gain);
retval[9] = MatT(ptr->errorCovPost);
return TensorArray(retval);
}
extern "C" struct TensorWrapper KalmanFilter_predict(struct KalmanFilterPtr ptr,
struct TensorWrapper control)
{
cv::Mat retval = control.toMat();
cv::Mat result = ptr->predict(retval);
return TensorWrapper(MatT(result));
}
struct TensorWrapper imencode(
const char *ext, struct TensorWrapper img, struct TensorWrapper params)
{
std::vector<unsigned char> retval;
cv::imencode(ext, img.toMat(), retval, params.toMat());
return TensorWrapper(MatT(cv::Mat(retval)));
}
struct TensorWrapper initCameraMatrix2D(
struct TensorArray objectPoints, struct TensorArray imagePoints,
struct SizeWrapper imageSize, double aspectRatio)
{
return TensorWrapper(MatT(cv::initCameraMatrix2D(
objectPoints.toMatList(), imagePoints.toMatList(),
imageSize, aspectRatio)));
}
struct TensorWrapper findFundamentalMat(
struct TensorWrapper points1, struct TensorWrapper points2, int method,
double param1, double param2, struct TensorWrapper mask)
{
return TensorWrapper(
MatT(cv::findFundamentalMat(points1.toMat(), points2.toMat(),
method, param1, param2,
TO_MAT_OR_NOARRAY(mask))));
}
void generateInitialWindows(
const cv::Mat &input,
const cv::Size &minSize,
const cv::Size &maxSize,
const int wsize,
std::vector<std::pair<MatT, float> > &scaledimages,
std::vector<cv::Rect> &rects,
std::vector<int> &scales)
{
rects.clear();
scales.clear();
// How many pixels to move the window for each step
// TODO : figure out if it makes sense to change this depending on
// the size of the scaled input image - i.e. it is possible that
// a small step size on an image scaled way larger than the input
// will end up detecting too much stuff ... each step on the larger
// image might not correspond to a step of 1 pixel on the
// input image?
const int step = 6;
//int step = std::min(img.cols, img.rows) *0.05;
double start = gtod_wrapper(); // grab start time
// The net expects each pixel to be 3x 32-bit floating point
// values. Convert it once here rather than later for every
// individual input image.
MatT f32Img;
MatT(input).convertTo(f32Img, CV_32FC3);
// Create array of scaled images
scalefactor(f32Img, cv::Size(wsize,wsize), minSize, maxSize, 1.35, scaledimages);
// Main loop. Look at each scaled image in turn
for (size_t scale = 0; scale < scaledimages.size(); ++scale)
{
// Start at the upper left corner. Loop through the rows and cols until
// the detection window falls off the edges of the scaled image
for (int r = 0; (r + wsize) < scaledimages[scale].first.rows; r += step)
{
for (int c = 0; (c + wsize) < scaledimages[scale].first.cols; c += step)
{
// Save location and image data for each sub-image
rects.push_back(cv::Rect(c, r, wsize, wsize));
scales.push_back(scale);
}
}
}
double end = gtod_wrapper();
std::cout << "Elapsed time = " << (end - start) << std::endl;
}
struct TensorArray findHomography2(
struct TensorWrapper srcPoints, struct TensorWrapper dstPoints,
struct TensorWrapper mask, int method, double ransacReprojThreshold)
{
std::vector<MatT> vec(2);
vec[1] = mask.toMatT();
vec[0] = MatT(cv::findHomography(srcPoints.toMat(), dstPoints.toMat(),
vec[1], method, ransacReprojThreshold));
return TensorArray(vec);
}
struct TensorArray findFundamentalMat2(
struct TensorWrapper points1, struct TensorWrapper points2,
struct TensorWrapper mask, int method, double param1, double param2)
{
std::vector<MatT> vec(2);
vec[1] = mask.toMatT();
vec[0] = MatT(cv::findFundamentalMat(points1.toMat(), points2.toMat(),
vec[1], method, param1, param2));
return TensorArray(vec);
}
struct TensorWrapper findEssentialMat(
struct TensorWrapper points1, struct TensorWrapper points2,
double focal, struct Point2dWrapper pp, int method, double prob,
double threshold, struct TensorWrapper mask)
{
return TensorWrapper(
MatT(cv::findEssentialMat(points1.toMat(), points2.toMat(),
focal, pp, method, prob, threshold,
TO_MAT_OR_NOARRAY(mask))));
}
extern "C" struct TensorWrapper DenseOpticalFlow_calc(struct DenseOpticalFlowPtr ptr,
struct TensorWrapper I0, struct TensorWrapper I1, struct TensorWrapper flow)
{
if (flow.isNull()) {
cv::Mat retval;
ptr->calc(I0.toMat(), I1.toMat(), retval);
return TensorWrapper(MatT(retval));
}
ptr->calc(I0.toMat(), I1.toMat(), flow.toMat());
return flow;
}
struct TensorWrapper findHomography(
struct TensorWrapper srcPoints, struct TensorWrapper dstPoints,
int method, double ransacReprojThreshold, struct TensorWrapper mask,
const int maxIters, const double confidence)
{
return TensorWrapper(
MatT(cv::findHomography(srcPoints.toMat(), dstPoints.toMat(),
method, ransacReprojThreshold,
TO_MAT_OR_NOARRAY(mask),
maxIters, confidence)));
}
struct TensorPlusRect getOptimalNewCameraMatrix(
struct TensorWrapper cameraMatrix, struct TensorWrapper distCoeffs,
struct SizeWrapper imageSize, double alpha, struct SizeWrapper newImgSize,
bool centerPrincipalPoint)
{
struct TensorPlusRect result;
cv::Rect validPixROI;
new(&result.tensor) TensorWrapper(
MatT(cv::getOptimalNewCameraMatrix(
cameraMatrix.toMat(), distCoeffs.toMat(),
imageSize, alpha, newImgSize,
&validPixROI, centerPrincipalPoint)));
result.rect = validPixROI;
return result;
}
extern "C" struct TensorArray calcOpticalFlowPyrLK(struct TensorWrapper prevImg,
struct TensorWrapper nextImg, struct TensorWrapper prevPts,
struct TensorWrapper nextPts, struct TensorWrapper status,
struct TensorWrapper err, struct SizeWrapper winSize, int maxLevel,
struct TermCriteriaWrapper criteria, int flags, double minEigThreshold)
{
std::vector<MatT> retval(3);
retval[1] = status.toMatT();
retval[2] = err.toMatT();
cv::calcOpticalFlowPyrLK(prevImg.toMat(), nextImg.toMat(), prevPts.toMat(), nextPts.toMat(), retval[1],
retval[2], winSize, maxLevel, criteria, flags, minEigThreshold);
retval[0] = MatT(nextPts);
return TensorArray(retval);
}
struct TensorWrapper calibrationMatrixValues(
struct TensorWrapper cameraMatrix,
struct SizeWrapper imageSize,
double apertureWidth, double apertureHeight)
{
cv::Mat retval(6,1,CV_64FC1);
cv::Point2d principalPoint_temp;
cv::calibrationMatrixValues(cameraMatrix.toMat(), imageSize, apertureWidth,
apertureHeight, retval.at<double>(0,0),
retval.at<double>(1,0), retval.at<double>(2,0),
principalPoint_temp, retval.at<double>(5,0));
retval.at<double>(3,0) = principalPoint_temp.x;
retval.at<double>(4,0) = principalPoint_temp.y;
return TensorWrapper(MatT(retval));
}
struct TensorWrapper TrainData_getTrainSamples(
struct TrainDataPtr ptr, int layout, bool compressSamples, bool compressVars)
{
return TensorWrapper(MatT(ptr->getTrainSamples(layout, compressSamples, compressVars)));
}
struct TensorWrapper TrainData_getCatMap(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getCatMap()));
}
struct TensorWrapper TrainData_getClassLabels(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getClassLabels()));
}
struct TensorWrapper TrainData_getDefaultSubstValues(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getDefaultSubstValues()));
}
struct TensorWrapper TrainData_getVarType(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getVarType()));
}
struct TensorWrapper TrainData_getNormCatResponses(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getNormCatResponses()));
}
struct TensorWrapper TrainData_getMissing(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getMissing()));
}
struct TensorWrapper readOpticalFlow(const char *path)
{
return TensorWrapper(MatT(optflow::readOpticalFlow(path)));
}
extern "C" struct TensorWrapper estimateRigidTransform(struct TensorWrapper src,
struct TensorWrapper dst, bool fullAffine)
{
return TensorWrapper(MatT(cv::estimateRigidTransform(src.toMat(), dst.toMat(), fullAffine)));
}
struct TensorWrapper TrainData_getSubVector(
struct TensorWrapper vec, struct TensorWrapper idx)
{
return TensorWrapper(MatT(ml::TrainData::getSubVector(vec.toMat(), idx.toMat())));
}
struct TensorWrapper TrainData_getSamples(struct TrainDataPtr ptr)
{
return TensorWrapper(MatT(ptr->getSamples()));
}
extern "C" struct TensorWrapper KalmanFilter_correct(struct KalmanFilterPtr ptr,
struct TensorWrapper measurement)
{
cv::Mat res = ptr->correct(measurement.toMat());
return TensorWrapper(MatT(res));
}
