int main(int argc, char *argv[])
{
if (argc < 6)
{
printf("Usage: image mask start end output\n");
return -1;
}
IplImage *srcMask, *dstMask;
char *imgPattern = argv[1];
char *maskPattern = argv[2];
int s = atoi(argv[3]);
int e = atoi(argv[4]);
char *output = argv[5];
char name[256];
int imgCount;
BiImage sift1, sift2, src, dst, tmp;
snprintf(name, 256, imgPattern, s);
ImageIO::LoadImage(name, src);
ExtractSIFT(src, sift1);
snprintf(name, 256, maskPattern, s);
srcMask = cvLoadImage(name, CV_LOAD_IMAGE_GRAYSCALE);
int width = src.width();
int height = src.height();
int channels = src.nchannels();
IntImage fv(0, width, height, 2);
for (imgCount = s + 1; imgCount <= e; imgCount++)
{
snprintf(name, 256, imgPattern, imgCount);
printf("processing %s...\n", name);
ImageIO::LoadImage(name, dst);
ExtractSIFT(dst, sift2);
snprintf(name, 256, maskPattern, imgCount);
dstMask = cvLoadImage(name, CV_LOAD_IMAGE_GRAYSCALE);
// layer flow
snprintf(name, 256, "%s_%d", output, imgCount);
LayerFlow(sift1, sift2, fv, srcMask, dstMask, name);
// save flow vector to image
tmp.setValue(0, width, height, channels);
FlowColorImage(fv, tmp);
snprintf(name, 256, "%s_fv_%d.bmp", output, imgCount);
ImageIO::WriteImage(name, tmp);
tmp.clear();
// save flow vector to file
snprintf(name, 256, "%s_fv_%d.dat", output, imgCount);
SaveAsFile(fv.data(), width, height, 2, name);
// warp image
tmp.setValue(0, width, height, 3);
WarpImage(src, fv, tmp);
snprintf(name, 256, "%s_warp_nobg_%d.bmp", output, imgCount);
ImageIO::WriteImage(name, tmp);
tmp.clear();
WarpImage(src, fv, dst);
src = dst;
snprintf(name, 256, "%s_warp_%d.bmp", output, imgCount);
ImageIO::WriteImage(name, src);
dst.clear();
// warp sift image
WarpImage(sift1, fv, sift2);
sift1 = sift2;
sift2.clear();
cvReleaseImage(&srcMask);
srcMask = cvCloneImage(dstMask);
cvReleaseImage(&dstMask);
}
cvReleaseImage(&srcMask);
return 0;
}
void OpticalFlow::baseCalculate(cv::Mat& Im1, cv::Mat& Im2, flowUV& UV, const OpticalFlowParams& params){
int rows = Im1.rows;
int cols = Im1.cols;
FlowOperator flowOp(rows, cols);
FArray X0(2 * rows * cols, false);
FArray dUdV(2 * rows * cols, true, 0);
cv::Mat Ix1(rows, cols, OPTFLOW_TYPE);
cv::Mat Iy1(rows, cols, OPTFLOW_TYPE);
cv::Mat Ix(rows, cols, OPTFLOW_TYPE);
cv::Mat Iy(rows, cols, OPTFLOW_TYPE);
getDXsCV(Im1, Ix1, Iy1);
for (int i = 0; i < params.getIters(); ++i){
cv::Mat Ix2(rows, cols, OPTFLOW_TYPE);
cv::Mat Iy2(rows, cols, OPTFLOW_TYPE);
cv::Mat It(rows, cols, OPTFLOW_TYPE);
cv::Mat im2Warpped(rows, cols, Im1.type());
WarpImage(Im2, UV.getU(), UV.getV(), im2Warpped);
getDXsCV(im2Warpped, Ix2, Iy2);
Ix = params.getWeightedDeriveFactor() * (Ix1 + Ix2);
Iy = params.getWeightedDeriveFactor() * (Iy1 + Iy2);
cv::subtract(im2Warpped, Im1, It);
if (params.getDisplayDerivativs()){
cv::imshow("Derivative Ix", Ix);
cv::imshow("Derivative Iy", Iy);
cv::waitKey(1);
}
cv::Mat Du(rows, cols, OPTFLOW_TYPE, cv::Scalar(0));
cv::Mat Dv(rows, cols, OPTFLOW_TYPE, cv::Scalar(0));
for (int j = 0; j < params.getLinearIters(); ++j){
#if OPTFLOW_VERBOSE
cout << "solving Ax=b with SOR ";
clock_t start = std::clock();
#endif
flowOp.construct(UV, Du, Dv, Ix, Iy, It, params);
memcpy(X0.ptr, UV.getU().data, rows * cols * sizeof(float));
memcpy(X0.ptr + (rows * cols), UV.getV().data, rows * cols * sizeof(float));
//UtilsDebug::printCRSSparseMat(flowOp.getA(), "aaaa.txt");
if (params.getCheckResidualTolerance()){
LinearSolver::sparseMatSor(flowOp.getA(), X0 ,dUdV, flowOp.getb(), params.getOverRelaxation(), params.getSorIters(), params.getResidualTolerance());
}else{
//LinearSolver::multigrid(10,10,flowOp.getA(),flowOp.getb(), params.getResidualTolerance(), dUdV, 20, 20, LinearSolver::vCycle);
LinearSolver::sparseMatSorNoResidual(flowOp.getA(), X0 ,dUdV, flowOp.getb(), params.getOverRelaxation(), params.getSorIters());
}
#if OPTFLOW_VERBOSE
std::cout<<" --- "<< (std::clock() - start) / (double)CLOCKS_PER_SEC <<'\n';
#endif
#if OPTFLOW_DEBUG
for(int i = 0; i < dUdV.size(); ++i){
if (!(dUdV.ptr[i] == dUdV.ptr[i])){
cout << "ERROR - NAN";
}
}
#endif
UtilsMat::clamp(dUdV, -1, 1);
memcpy(Du.data, dUdV.ptr, rows * cols * sizeof(float));
memcpy(Dv.data, dUdV.ptr + (rows * cols), rows * cols * sizeof(float));
flowUV UV0(UV);
UV.getU() += Du;
UV.getV() += Dv;
cv::Mat tmpU, tmpV;
UV.getU().copyTo(tmpU);
UV.getV().copyTo(tmpV);
WeightedMedianFilter::computeMedianFilter(UV.getU(), UV.getV(), Im1, Im2, params.getMedianFilterRadius());
Du = UV.getU() - UV0.getU();
Dv = UV.getV() - UV0.getV();
UV0.getU().copyTo(UV.getU());
UV0.getV().copyTo(UV.getV());
UV0.getU() += Du;
UV0.getV() += Dv;
if (params.isDisplay())
UtilsFlow::DrawFlow(UV0.getU(), UV0.getV(), "Flow");
}
UV.getU() += Du;
UV.getV() += Dv;
}
}
int main()
{
const int triangleCount = 111;
const int trianglePoints = 68;
const Vec2i resolution(169, 167);
std::string meanShape = "Data/Mean_Shape.txt";
std::string currentShape = "Data/Current_Shape.txt";
std::string triangles = "Data/Triangles.txt";
std::string textureBase = "Data/Texture_Base.txt";
std::string imageName = "Data/inputImage.png";
cv::Mat inputImage = cv::imread(imageName, CV_LOAD_IMAGE_GRAYSCALE);
if(!inputImage.data)
{
std::cerr << "Could not open or find the image" << std::endl;
std::exit(EXIT_FAILURE);
}
std::vector<Vec2i> trianglePointsList[triangleCount];
LoadTextureBase(textureBase, resolution, trianglePointsList);
// load points rounded to nearest int
Vec2i* meanPoints = new Vec2i[trianglePoints];
LoadShape(meanShape, meanPoints);
Vec2i* currentPoints = new Vec2i[trianglePoints];
LoadShape(currentShape, currentPoints);
// load points as floats
Vec2f* meanPointsf = new Vec2f[trianglePoints];
LoadShapef(meanShape, meanPointsf);
Vec2f* currentPointsf = new Vec2f[trianglePoints];
LoadShapef(currentShape, currentPointsf);
Index* indices = new Index[triangleCount];
LoadIndices(triangles, indices);
cv::Mat outImage = cv::Mat::zeros(resolution.y, resolution.x, inputImage.type());
clock_t timeC;
int loops = 10000;
timeC = clock();
for(int y = 0; y < loops; ++y)
{
WarpImage(meanPoints, currentPoints, indices, triangleCount, trianglePointsList, inputImage, outImage);
}
timeC = clock() - timeC;
std::cout << "WarpImage time to do " << loops << " loops: " << timeC * 1000 / CLOCKS_PER_SEC << " milliseconds." << std::endl;
cv::Mat outImagef = cv::Mat::zeros(resolution.y, resolution.x, inputImage.type());
timeC = clock();
for(int y = 0; y < loops; ++y)
{
WarpImagef(meanPointsf, currentPointsf, indices, triangleCount, trianglePointsList, inputImage, outImagef);
}
timeC = clock() - timeC;
std::cout << "WarpImagef time to do " << loops << " loops: " << timeC * 1000 / CLOCKS_PER_SEC << " milliseconds." << std::endl;
cv::namedWindow("WarpImage image", CV_WINDOW_AUTOSIZE );
cv::imshow("WarpImage image", outImage);
cv::namedWindow("WarpImage imagef", CV_WINDOW_AUTOSIZE );
cv::imshow("WarpImage imagef", outImagef);
cv::waitKey(0);
delete[] indices;
delete[] currentPointsf;
delete[] meanPointsf;
delete[] currentPoints;
delete[] meanPoints;
return 0;
}
