static void image_jacobian_affine_ECC(const Mat& src1, const Mat& src2,
const Mat& src3, const Mat& src4,
Mat& dst)
{
CV_Assert(src1.size() == src2.size());
CV_Assert(src1.size() == src3.size());
CV_Assert(src1.size() == src4.size());
CV_Assert(src1.rows == dst.rows);
CV_Assert(dst.cols == (6*src1.cols));
CV_Assert(dst.type() == CV_32FC1);
const int w = src1.cols;
//compute Jacobian blocks (6 blocks)
dst.colRange(0,w) = src1.mul(src3);//1
dst.colRange(w,2*w) = src2.mul(src3);//2
dst.colRange(2*w,3*w) = src1.mul(src4);//3
dst.colRange(3*w,4*w) = src2.mul(src4);//4
src1.copyTo(dst.colRange(4*w,5*w));//5
src2.copyTo(dst.colRange(5*w,6*w));//6
}
static void image_jacobian_euclidean_ECC(const Mat& src1, const Mat& src2,
const Mat& src3, const Mat& src4,
const Mat& src5, Mat& dst)
{
CV_Assert( src1.size()==src2.size());
CV_Assert( src1.size()==src3.size());
CV_Assert( src1.size()==src4.size());
CV_Assert( src1.rows == dst.rows);
CV_Assert(dst.cols == (src1.cols*3));
CV_Assert(dst.type() == CV_32FC1);
CV_Assert(src5.isContinuous());
const float* hptr = src5.ptr<float>(0);
const float h0 = hptr[0];//cos(theta)
const float h1 = hptr[3];//sin(theta)
const int w = src1.cols;
//create -sin(theta)*X -cos(theta)*Y for all points as a block -> hatX
Mat hatX = -(src3*h1) - (src4*h0);
//create cos(theta)*X -sin(theta)*Y for all points as a block -> hatY
Mat hatY = (src3*h0) - (src4*h1);
//compute Jacobian blocks (3 blocks)
dst.colRange(0, w) = (src1.mul(hatX))+(src2.mul(hatY));//1
src1.copyTo(dst.colRange(w, 2*w));//2
src2.copyTo(dst.colRange(2*w, 3*w));//3
}
Mat get_ft(Mat &src1, Mat &src2){
Mat ft;
Mat kernel = Mat::ones(2, 2, CV_64FC1);
kernel = kernel.mul(-1);
Mat dst1, dst2;
filter2D(src1, dst1, -1, kernel);
kernel = kernel.mul(-1);
filter2D(src2, dst2, -1, kernel);
ft = dst1 + dst2;
return ft;
}
void blendLapPyrs() {
//获得每层金字塔中直接用左右两图Laplacian变换拼成的图像resultLapPyr
resultHighestLevel = leftHighestLevel.mul(maskGaussianPyramid.back()) +
rightHighestLevel.mul(Scalar(1.0,1.0,1.0) - maskGaussianPyramid.back());
for (int l=0; l<levels; l++) {
Mat A = leftLapPyr[l].mul(maskGaussianPyramid[l]);
Mat antiMask = Scalar(1.0,1.0,1.0) - maskGaussianPyramid[l];
Mat B = rightLapPyr[l].mul(antiMask);
Mat_<Vec3f> blendedLevel = A + B;
resultLapPyr.push_back(blendedLevel);
}
}
// ----------------------------------------------------------------------------
//
// private function impl
//
// ----------------------------------------------------------------------------
void FCDropoutLayer::fpropOne(Mat &ouFeatMaps, Mat &mask,
const Mat &inFeatMaps,
const float dropoutRate,
const bool isStaticMask)
{
float scale = 1 / (1 - dropoutRate);
if (!isStaticMask) {
cv::randu(mask, 0, 1);
cv::threshold(mask, mask, dropoutRate, scale, CV_THRESH_BINARY);
ouFeatMaps = inFeatMaps.mul(mask);
}
else
ouFeatMaps = inFeatMaps.mul(mask);
}
Mat cvt2NonLinear(Mat srcImg) {
int choice;
double c;
cout << "\nCHUYEN MAU THEO MO HINH PHI TUYEN TINH" << endl;
cout << "Chon 1 trong 2 cach sau: " << endl;
cout << " 1.Chuyen theo ham logarithm." << endl;
cout << " 2.Chuyen theo ham mu." << endl;
cout << "Lua chon: ";
cin >> choice;
switch (choice) {
case 1: {
cout << " - Nhap gia tri c: ";
cin >> c;
myfunc_nonLinearChange_Log(srcImg, c);
// Tạo ảnh kết quả (res) có kích thước và kiểu giống ảnh gốc (srcImg) nhưng các giá trị = 0
Mat res = Mat::zeros(srcImg.size(), srcImg.type());
// + 1 để tránh log(0)
srcImg = srcImg + 1;
// Chuyển định dạng pixel của ảnh gốc (srcImg) thành CV_32F - dạng float để tính logarithm
srcImg.convertTo(srcImg, CV_32F);
// Ảnh kết quả = log(Ảnh gốc)
log(srcImg, res);
// Chuyển về [0..255]
normalize(res, res, 0, 255, NORM_MINMAX);
convertScaleAbs(res, res);
// Ảnh kết quả = Ảnh kết quả * c
res.mul(res, c);
return res;
}
case 2: {
cout << " - Nhap gia tri c: ";
cin >> c;
myfunc_nonLinearChange_Exp(srcImg, c);
// Tạo ảnh kết quả (res) có kích thước và kiểu giống ảnh gốc (srcImg) nhưng các giá trị = 0
Mat res = Mat::zeros(srcImg.size(), srcImg.type());
// Chuyển định dạng pixel của ảnh gốc (srcImg) thành CV_32F - dạng float để tính logarithm
srcImg.convertTo(srcImg, CV_32F);
// Ảnh kết quả = e ^ (Ảnh gốc)
exp(srcImg, res);
res.mul(c);
return res;
}
default:
return Mat();
}
}
/* finds the convolution of a matrix and kernel
* the input should be an 1-channel floating point image
* written as an illustration only */
int naive_convolution(const Mat& input, Mat& output, const Mat& kernel)
{
int krows = kernel.rows;
int kcols = kernel.cols;
/* region of interest */
Mat roi = input(cv::Rect(0, 0, krows, kcols));
for (int r = 0; r < output.rows; r++) {
for (int c = 0; c < output.cols; c++) {
float& pixel = output.at<float>(r, c);
if ((r < krows / 2) || (r > output.rows - krows / 2 - 1)
|| (c < kcols / 2) || (c > output.cols - kcols / 2 - 1)) {
/* set out of bounds pixels to black */
pixel = 0;
} else {
/* move the ROI */
roi = input(cv::Rect(c - kcols / 2, r - krows / 2,
kcols, krows));
/* perform element-wise multiplication and take the sum
* to get the value of the current pixel */
pixel = sum(kernel.mul(roi))[0];
}
}
}
return 0;
}
void FiltreElip::goFiltre(Mat& img, Mat& gray, Mat& effet){
Mat work_on;
if(_image_we_work_on==0){
equalizeHist( gray, work_on );
}
else{
equalizeHist( effet, work_on );
}
int rows=work_on.rows;
int cols=work_on.cols;
// std::cout << rows << " rows" << std::endl;
// std::cout << cols << " cols" << std::endl;
int trying=0;
for(int i=0;i<rows-_filtre1.rows;i=i+5){
for(int j=0;j<cols-_filtre1.cols;j=j+5){
Mat tmp = work_on(Range(i,i+_filtre1.rows), Range(j,j+_filtre1.cols));
tmp.mul(_filtre1);
trying=sum(tmp).val[0];
if(_sum1>trying || _sum1==-1){
//std::cout<<"sum : "<<_sum1 <<" "<< trying << std::endl;
_sum1=trying;
_rec1=Rect(j,i,_filtre1.rows,_filtre1.cols);
}
}
}
}
void TileHolder::makeTile(const GridPt &tilePt, ImgFetcher &fetch, Mat &out, Mat &bg) {
Point2f tileTl(tl.x + tilePt[0] * tileSz.width, tl.y + tilePt[1] * tileSz.height);
const set<ImData> &bin = getBin(tilePt);
out = Mat::zeros(tileSz, CV_32FC1);//gather the tile data in out
Mat weightIm = Mat::zeros(tileSz, CV_32FC1) + FLT_MIN;//+ 1e-90; // avoid divide by zero, maybe static this?
Mat curIm;
for (const ImData &dat : bin) {
fetch.getMat(dat.file, curIm);
if (curIm.type() == CV_8U) {
curIm.convertTo(curIm, CV_32F, 1. / 255);
} else if (curIm.type() != CV_32F) {
fprintf(stderr, "err: bad image type\n");
exit(1);
}
if (bg.data)
{
assert(bg.size() == curIm.size());
curIm -= bg;
}
std::cout << dat.file << std::endl;
//saveFloatIm("testsomewhere.tif", weightMat);
blit(curIm.mul(weightMat), out, dat.pos - tileTl);
blit(weightMat, weightIm, dat.pos - tileTl);
}
out /= weightIm;
}
/**
* Get the average image at the given altitude.
* If the altitude is not located exactly at one of the altitude bins,
* the average image is interpolated between any overlapping bins.
* @param _dst the output image (zeros at desired resolution)
* @param alt the altitude the image was taken at
* @param pitch the pitch of the vehicle
* @param roll the roll of the vehicle
*/
void getAverage(cv::OutputArray _dst, double alt, double pitch, double roll) {
Mat dst = _dst.getMat();
int width = dst.size().width;
int height = dst.size().height;
Mat D = Mat::zeros(height, width, CV_32F);
double width_m = width * cameras.pixel_sep;
double height_m = height * cameras.pixel_sep;
interp::distance_map(D, alt, pitch, roll, width_m, height_m, cameras.focal_length);
// now discretize into slices
int i = 0;
Mat W = Mat::zeros(D.size(), CV_32F);
while(cv::countNonZero(W) == 0) {
interp::dist_weight(D, W, alt_step, i++);
}
while(cv::countNonZero(W) > 0) {
Slice<int>* slice = getSlice(i);
Mat sAverage;
// get the slice average
boost::mutex* mutex = slice->get_mutex();
{ // protect slice with mutex to prevent interleaved read/write operations
boost::lock_guard<boost::mutex> lock(*mutex);
sAverage = slice->getLightfield()->getAverage();
}
dst += sAverage.mul(W); // multiply by slice weight
interp::dist_weight(D, W, alt_step, i++);
}
}
void process(InputArray _src, OutputArray _dst)
{
Mat src = _src.getMat();
CV_Assert(!src.empty());
_dst.create(src.size(), CV_32FC3);
Mat img = _dst.getMat();
Ptr<Tonemap> linear = createTonemap(1.0f);
linear->process(src, img);
Mat gray_img;
cvtColor(img, gray_img, COLOR_RGB2GRAY);
Mat log_img;
log(gray_img, log_img);
float mean = expf(static_cast<float>(sum(log_img)[0]) / log_img.total());
gray_img /= mean;
log_img.release();
double max;
minMaxLoc(gray_img, NULL, &max);
Mat map;
log(gray_img + 1.0f, map);
Mat div;
pow(gray_img / static_cast<float>(max), logf(bias) / logf(0.5f), div);
log(2.0f + 8.0f * div, div);
map = map.mul(1.0f / div);
div.release();
mapLuminance(img, img, gray_img, map, saturation);
linear->setGamma(gamma);
linear->process(img, img);
}
void ImageCB(const sensor_msgs::ImageConstPtr& msg) {
cv_bridge::CvImagePtr cv_ptr;
Mat frame;
Mat output;
try {
cv_ptr = cv_bridge::toCvCopy(msg, "bgr8");
} catch (cv_bridge::Exception& e) {
ROS_ERROR("CV-Bridge error: %s", e.what());
return;
}
frame = cv_ptr->image;
frame = frame.mul(mask);
Mat white_lines = findWhiteLines(frame);
Mat blue_lines = findBlueLines(frame);
Mat yellow_lines = findYellowLines(frame);
Mat orange_blobs = findOrange(frame);
output = white_lines + blue_lines + yellow_lines + orange_blobs;
sensor_msgs::Image outmsg;
cv_ptr->image = output;
cv_ptr->encoding = "bgr8";
cv_ptr->toImageMsg(outmsg);
img_pub.publish(outmsg);
}
Mat dSigmoid(Mat& mat)
{
Mat res = 1.0 - mat;
res = res.mul(mat);
return res;
}
void signedPow(Mat src, float power, Mat& dst)
{
Mat sign = (src > 0);
sign.convertTo(sign, CV_32F, 1.0f/255.0f);
sign = sign * 2.0f - 1.0f;
pow(abs(src), power, dst);
dst = dst.mul(sign);
}
void specgram::specgram_to_cepsgram(const Mat& specgram,
const Mat& filter_bank,
Mat& cepsgram)
{
cepsgram = (specgram.mul(specgram) / specgram.cols) * filter_bank;
cv::log(cepsgram, cepsgram);
return;
}
Mat PhaseShiftCoefficientRealPart(Mat laplevel, Mat rieszXLevel, Mat rieszYLevel, Mat phaseMagnifiedCos, Mat phaseMagnifiedSin)
{
Mat r;
Mat pm,expPhaseReal,expPhaseImag;
Mat expphix,expphiy,tmp;
sqrt(phaseMagnifiedCos.mul(phaseMagnifiedCos)+phaseMagnifiedSin.mul(phaseMagnifiedSin),pm);
expPhaseReal = Cos(pm);
expPhaseImag = Sin(pm);
divide(expPhaseImag,pm,tmp);
expphix = phaseMagnifiedCos.mul(tmp);
expphiy = phaseMagnifiedSin.mul(tmp);
r = expPhaseReal.mul(laplevel)-expphix.mul(rieszXLevel)-expphiy.mul(rieszYLevel);
return r;
}
// These can all be static
void specgram::wav_to_specgram(const Mat& wav_col_mat,
const int frame_length_tn,
const int frame_stride_tn,
const int max_time_steps,
const Mat& window,
Mat& specgram)
{
// const Mat& wav_mat = wav.get_data();
// Read as a row vector
Mat wav_mat = wav_col_mat.reshape(1, 1);
// TODO: support more sample formats
if (wav_mat.elemSize1() != 2) {
throw std::runtime_error(
"Unsupported number of bytes per sample: " + std::to_string(wav_mat.elemSize1()));
}
// Go from time domain to strided signal
Mat wav_frames;
{
int num_frames = ((wav_mat.cols - frame_length_tn) / frame_stride_tn) + 1;
num_frames = std::min(num_frames, max_time_steps);
// ensure that there is enough data for at least one frame
assert(num_frames >= 0);
wav_frames.create(num_frames, frame_length_tn, wav_mat.type());
for (int frame = 0; frame < num_frames; frame++) {
int start = frame * frame_stride_tn;
int end = start + frame_length_tn;
wav_mat.colRange(start, end).copyTo(wav_frames.row(frame));
}
}
// Prepare for DFT by converting to float
Mat input;
wav_frames.convertTo(input, CV_32FC1);
// Apply window if it has been created
if (window.cols == frame_length_tn) {
input = input.mul(cv::repeat(window, input.rows, 1));
}
Mat planes[] = {input, Mat::zeros(input.size(), CV_32FC1)};
Mat compx;
cv::merge(planes, 2, compx);
cv::dft(compx, compx, cv::DFT_ROWS);
compx = compx(Range::all(), Range(0, frame_length_tn / 2 + 1));
cv::split(compx, planes);
cv::magnitude(planes[0], planes[1], planes[0]);
// NOTE: at this point we are returning the specgram representation in
// (time_steps, freq_steps) shape order.
specgram = planes[0];
return;
}
//Rate a location on how likely it is to be a bubble
double rateBubble(Mat& det_img_gray, Point bubble_location, PCA& my_PCA){
Mat query_pixels, pca_components;
getRectSubPix(det_img_gray, Point(14,18), bubble_location, query_pixels);
query_pixels.reshape(0,1).convertTo(query_pixels, CV_32F);
pca_components = my_PCA.project(query_pixels);
//The rating is the SSD of query pixels and their back projection
Mat out = my_PCA.backProject(pca_components)- query_pixels;
return sum(out.mul(out)).val[0];
}
/* Removes yellow lines from the image by minimizing the edges when
calculating green*(1+lambda)-blue*lambda.
*/
void removeyellow(Mat& img) {
vector<Mat> bgr;
split(img, bgr);
Mat g = bgr[1]-1.0;
Mat b = bgr[0]-1.0;
double lambda = mean(g.mul(b-g))[0]/mean(g.mul(g)-2*g.mul(b)+b.mul(b))[0];
LOGI("Remove yellow lambda = %f", lambda);
// REMOVED BECAUSE NOT NEEDED ON IDEOS and lambda=0.53
//bgr[1]=bgr[1]*(1+lambda)-bgr[0]*lambda;
// Also reset blue
bgr[0]=bgr[1];
merge(bgr, img);
}
double ParticleTrackingAlg::calcDistance(const Mat &histOrig, const Mat &histTmp)
{
double distanceSum = 0.0, firstLen = 0.0, secondLen = 0.0;
//std::cout<<"========="<<std::endl<<histOrig<<std::endl<<histTmp<<std::endl;//
Mat result = histOrig.mul(histTmp);
sqrt(result, result);
distanceSum = sum(result).val[0];
return distanceSum;
}
void coherenceEnhancingShockFilter(cv::InputArray src, cv::OutputArray dest_, const int sigma, const int str_sigma_, const double blend, const int iter)
{
Mat dest = src.getMat();
const int str_sigma = min(31, str_sigma_);
for (int i = 0; i < iter; i++)
{
Mat gray;
if (src.channels() == 3)cvtColor(dest, gray, CV_BGR2GRAY);
else gray = dest;
Mat eigen;
if (gray.type() == CV_8U || gray.type() == CV_32F || gray.type() == CV_64F)
cornerEigenValsAndVecs(gray, eigen, str_sigma, 3);
else
{
Mat grayf; gray.convertTo(grayf, CV_32F);
cornerEigenValsAndVecs(grayf, eigen, str_sigma, 3);
}
vector<Mat> esplit(6);
split(eigen, esplit);
Mat x = esplit[2];
Mat y = esplit[3];
Mat gxx;
Mat gyy;
Mat gxy;
Sobel(gray, gxx, CV_32F, 2, 0, sigma);
Sobel(gray, gyy, CV_32F, 0, 2, sigma);
Sobel(gray, gxy, CV_32F, 1, 1, sigma);
Mat gvv = x.mul(x).mul(gxx) + 2 * x.mul(y).mul(gxy) + y.mul(y).mul(gyy);
Mat mask;
compare(gvv, 0, mask, cv::CMP_LT);
Mat di, ero;
erode(dest, ero, Mat());
dilate(dest, di, Mat());
di.copyTo(ero, mask);
addWeighted(dest, blend, ero, 1.0 - blend, 0.0, dest);
}
dest.copyTo(dest_);
}
Mat Camera::computePMatrix() {
Mat AR = computeCalibrationMatrix() * computeRotationMatrix();
printMat("A", computeCalibrationMatrix());
printMat("R", computeRotationMatrix());
Mat ARC = AR * computeCameraCenterMatrix(false);
Mat p;
hconcat(AR, ARC.mul(-1), p);
printMat("P", p);
return p;
}
/*
Implements colorspace noise perturbation as described in:
Krizhevsky et. al., "ImageNet Classification with Deep Convolutional Neural Networks"
Constructs a random coloring pixel that is uniformly added to every pixel of the image.
pixelstd is filled with normally distributed values prior to calling this function.
*/
void lighting(Mat& inout, float pixelstd[]) {
// Skip transformations if given deterministic settings
if (_params->_colorNoiseStd == 0.0) {
return;
}
Mat alphas(3, 1, CV_32FC1, pixelstd);
alphas = (CPCA * CSTD.mul(alphas)); // this is the random coloring pixel
auto pixel = alphas.reshape(3, 1).at<Scalar_<float>>(0, 0);
inout = (inout + pixel) / (1.0 + _params->_colorNoiseStd);
}
void ncc(Mat L, Mat R, Mat &imd) {
Mat Lb, Rb;
boxFilter(L, Lb, nccsize);
boxFilter(R, Rb, nccsize);
Mat LL = L.mul(L);
Mat RR = R.mul(R);
Mat LR = L.mul(R);
Mat LLb, RRb, LRb;
boxFilter(LL, LLb, nccsize);
boxFilter(RR, RRb, nccsize);
boxFilter(LR, LRb, nccsize);
Mat LL2 = LLb - Lb.mul(Lb);
Mat RR2 = RRb - Rb.mul(Rb);
Mat LR2 = LRb - Lb.mul(Rb);
Mat den = LL2.mul(RR2) + ncceps;
sqrt(den, den);
Mat ncc = LR2 / den;
ncc.convertTo(imd, CV_8U, 128, 128);
}
void WhitenessFilter(Mat& hsv_image, Mat& fin_img) {
Mat result = 255 * Mat::ones(hsv_image.size(), CV_16UC1);
Mat tmp;
hsv_image.convertTo(tmp, CV_16UC3, 1.0);
Mat channel[3];
split(tmp, channel);
result = result - channel[1];
result = result.mul(channel[2]);
result.convertTo(fin_img, CV_8UC1, 1.0/255);
}
void lowPassFilter(Mat &F)
{
Mat H(F.rows, F.cols, CV_32FC2, Scalar(0, 0));
swapFreq(F);
circle(H, Point(H.cols/2, H.rows/2), 200, Scalar::all(1), -1);
F = F.mul(H);
swapFreq(F);
}
void MultiplyByComplements(Mat* images, Mat* complements, Mat* results) {
for(size_t i = 0; i < KERNAL_COUNT; i++) {
Mat image;
Mat complement;
Mat result = Mat::zeros(images[0].size(), CV_16UC1);
images[i].convertTo(image, CV_16UC1, 1.0);
complements[i].convertTo(complement, CV_16UC1, 1.0);
result = image.mul(complement);
result.convertTo(results[i], CV_8UC1, 1.0/255); // TODO figure this const out
}
}
Mat SegmentationUtility::obtainImageWithBoundary(
const Mat& inputImage, const Mat& segImage) {
Mat segmentedImage;
normalize(segImage, segmentedImage, 0.0, 1.0, cv::NORM_MINMAX, CV_32FC3);
Mat boundaryImage =
SegmentationUtility::computeBoundary(segmentedImage);
boundaryImage = multiply(boundaryImage, cv::Scalar(255, 255, 0));
Mat contourImage = inputImage;
return contourImage + contourImage.mul(boundaryImage);
}
vector<Mat> DifferencePhaseAmplitude(Mat &c_real, Mat &cRzX, Mat &cRzY, Mat &p_real, Mat &pRzX, Mat &pRzY )
{
vector<Mat> v(3);
{
Mat qconjReal=c_real.mul(p_real) + cRzX.mul(pRzX) + cRzY.mul(pRzY);
Mat qconjX= -c_real.mul(pRzX)+p_real.mul(cRzX);
Mat qconjY= -c_real.mul(pRzY)+p_real.mul(cRzY);
Mat num=qconjX.mul(qconjX)+qconjY.mul(qconjY);
Mat qconjAmplitude;
sqrt(qconjReal.mul(qconjReal)+num,qconjAmplitude);
Mat ratio;
divide(qconjReal, qconjAmplitude, ratio);
Mat diffPhase = ArcCos(ratio);
Mat cosAngle;
Mat sinAngle;
divide(qconjX,num,cosAngle);
divide(qconjY,num,sinAngle);
Mat diffPhaseCos=diffPhase.mul(cosAngle);
Mat diffPhaseSin=diffPhase.mul(sinAngle);
Mat amplitude;
sqrt(qconjAmplitude,amplitude);
v[0]=diffPhaseCos;
v[1]=diffPhaseSin;
v[2]=amplitude;
DisplayImage(c_real, "phasecos");
DisplayImage(cRzX, "phaseSion");
DisplayImage(cRzY, "p");
}
return v;
}
void projectImage(
double* arrar,
vector<Point3d> vec,
Mat imageVector,
const char* filename,
int n)
{
Mat projectMat = Mat(3,3, CV_64F,arrar); //生成一个投影矩阵，将三维点投影到二维平面上
Mat PointMat = Mat(vec).reshape(1).t(); //投影矩阵与三维点阵乘积
Mat result;
result = projectMat * PointMat;
Mat G = result.row(0).clone(); //生成图像上的二维点阵
Mat H = result.row(1).clone();
Mat J = result.row(2).clone();
vconcat(G.mul(1/J),H.mul(1/J),imageVector);
imageVector = imageVector.t();
Mat delimav; //去掉负数项,得到最终投影后的有效点
int t = n+1,count =0;
for(int i=0;i<t;i++)
if(imageVector.at<double>(i,0) < 0 || imageVector.at<double>(i,1) < 0
||imageVector.at<double>(i,0) >1 || imageVector.at<double>(i,1) >1)
{
Mat front = imageVector(Range(0,i),Range::all());
Mat back = imageVector(Range(i+1,t),Range::all());
vconcat(front,back,delimav);
imageVector.release();
imageVector = delimav.clone();
//--------------------//
i--;
t--;
} // imageVector为投影后的坐标
printFile(imageVector, filename);
}