/*
 * InterfaceVisualSFM.cpp
 *
 * Copyright (c) 2014-2015 SEACAVE
 *
 * Author(s):
 *
 *      cDc <cdc.seacave@gmail.com>
 *
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Additional Terms:
 *
 *      You are required to preserve legal notices and author attributions in
 *      that material or in the Appropriate Legal Notices displayed by works
 *      containing it.
 */

#include "../../libs/MVS/Common.h"
#include "../../libs/MVS/Scene.h"
#define LOG_OUT() GET_LOG()
#define LOG_ERR() GET_LOG()
#include "Util.h"
#include <boost/program_options.hpp>


// D E F I N E S ///////////////////////////////////////////////////

#define APPNAME _T("InterfaceVisualSFM")
#define MVS_EXT _T(".mvs")
#define VSFM_EXT _T(".nvm")
#define BUNDLE_EXT _T(".out")
#define CMPMVS_EXT _T(".lst")


// S T R U C T S ///////////////////////////////////////////////////

namespace {

namespace OPT {
String strInputFileName;
String strOutputFileName;
String strOutputImageFolder;
bool IsFromOpenMVS; // conversion direction
unsigned nArchiveType;
int nProcessPriority;
unsigned nMaxThreads;
String strConfigFileName;
boost::program_options::variables_map vm;
} // namespace OPT

class Application {
public:
	Application() {}
	~Application() { Finalize(); }

	bool Initialize(size_t argc, LPCTSTR* argv);
	void Finalize();
}; // Application

// initialize and parse the command line parameters
bool Application::Initialize(size_t argc, LPCTSTR* argv)
{
	// initialize log and console
	OPEN_LOG();
	OPEN_LOGCONSOLE();

	// group of options allowed only on command line
	boost::program_options::options_description generic("Generic options");
	generic.add_options()
		("help,h", "produce this help message")
		("working-folder,w", boost::program_options::value<std::string>(&WORKING_FOLDER), "working directory (default current directory)")
		("config-file,c", boost::program_options::value<std::string>(&OPT::strConfigFileName)->default_value(APPNAME _T(".cfg")), "file name containing program options")
		("archive-type", boost::program_options::value(&OPT::nArchiveType)->default_value(ARCHIVE_DEFAULT), "project archive type: 0-text, 1-binary, 2-compressed binary")
		("process-priority", boost::program_options::value(&OPT::nProcessPriority)->default_value(-1), "process priority (below normal by default)")
		("max-threads", boost::program_options::value(&OPT::nMaxThreads)->default_value(0), "maximum number of threads (0 for using all available cores)")
		#if TD_VERBOSE != TD_VERBOSE_OFF
		("verbosity,v", boost::program_options::value(&g_nVerbosityLevel)->default_value(
			#if TD_VERBOSE == TD_VERBOSE_DEBUG
			3
			#else
			2
			#endif
			), "verbosity level")
		#endif
		;

	// group of options allowed both on command line and in config file
	boost::program_options::options_description config("Main options");
	config.add_options()
		("input-file,i", boost::program_options::value<std::string>(&OPT::strInputFileName), "input filename containing camera poses and image list (NVM, undistorted OUT + image_list.TXT, LST)")
		("output-file,o", boost::program_options::value<std::string>(&OPT::strOutputFileName), "output filename for storing the mesh")
		("output-image-folder", boost::program_options::value<std::string>(&OPT::strOutputImageFolder)->default_value("undistorted_images"), "output folder to store undistorted images")
		;

	boost::program_options::options_description cmdline_options;
	cmdline_options.add(generic).add(config);

	boost::program_options::options_description config_file_options;
	config_file_options.add(config);

	boost::program_options::positional_options_description p;
	p.add("input-file", -1);

	try {
		// parse command line options
		boost::program_options::store(boost::program_options::command_line_parser((int)argc, argv).options(cmdline_options).positional(p).run(), OPT::vm);
		boost::program_options::notify(OPT::vm);
		INIT_WORKING_FOLDER;
		// parse configuration file
		std::ifstream ifs(MAKE_PATH_SAFE(OPT::strConfigFileName));
		if (ifs) {
			boost::program_options::store(parse_config_file(ifs, config_file_options), OPT::vm);
			boost::program_options::notify(OPT::vm);
		}
	}
	catch (const std::exception& e) {
		LOG(e.what());
		return false;
	}

	// initialize the log file
	OPEN_LOGFILE(MAKE_PATH(APPNAME _T("-")+Util::getUniqueName(0)+_T(".log")).c_str());

	// print application details: version and command line
	Util::LogBuild();
	LOG(_T("Command line: ") APPNAME _T("%s"), Util::CommandLineToString(argc, argv).c_str());

	// validate input
	Util::ensureValidPath(OPT::strInputFileName);
	Util::ensureUnifySlash(OPT::strInputFileName);
	if (OPT::vm.count("help") || OPT::strInputFileName.IsEmpty()) {
		boost::program_options::options_description visible("Available options");
		visible.add(generic).add(config);
		GET_LOG() << visible;
	}
	if (OPT::strInputFileName.IsEmpty())
		return false;

	// initialize optional options
	if (OPT::strInputFileName.IsEmpty())
		return false;
	Util::ensureValidPath(OPT::strOutputFileName);
	Util::ensureUnifySlash(OPT::strOutputFileName);
	Util::ensureUnifySlash(OPT::strOutputImageFolder);
	Util::ensureFolderSlash(OPT::strOutputImageFolder);
	const String strInputFileNameExt(Util::getFileExt(OPT::strInputFileName).ToLower());
	OPT::IsFromOpenMVS = (strInputFileNameExt == MVS_FILE_EXTENSION);
	if (OPT::IsFromOpenMVS) {
		if (OPT::strOutputFileName.empty())
			OPT::strOutputFileName = Util::getFilePath(OPT::strInputFileName);
	} else {
		if (OPT::strOutputFileName.empty())
			OPT::strOutputFileName = Util::getFilePath(OPT::strInputFileName) + _T("scene") MVS_FILE_EXTENSION;
		else
			OPT::strOutputImageFolder = Util::getRelativePath(Util::getFilePath(OPT::strOutputFileName), Util::getFilePath(OPT::strInputFileName)+OPT::strOutputImageFolder);
	}

	MVS::Initialize(APPNAME, OPT::nMaxThreads, OPT::nProcessPriority);
	return true;
}

// finalize application instance
void Application::Finalize()
{
	MVS::Finalize();

	CLOSE_LOGFILE();
	CLOSE_LOGCONSOLE();
	CLOSE_LOG();
}

} // unnamed namespace

#define PBA_PRECISION float

namespace PBA {
template<class FT> struct CameraT_;
typedef CameraT_<PBA_PRECISION> Camera;
template<class FT> struct Point3D_;
typedef Point3D_<PBA_PRECISION> Point3D;
} // namespace PBA

namespace MVS {
// given an undistorted pixel coordinate and one radial-undistortion parameter,
// compute the corresponding distorted coordinate
template<typename TYPE>
inline TPoint2<TYPE> DistortPointR1(const TPoint2<TYPE>& pt, const REAL& k1) {
	if (k1 == 0)
		return pt;
	const REAL y(pt.y == 0 ? REAL(1.e-12) : REAL(pt.y));
	const REAL t2(y*y);
	const REAL t3(t2*t2*t2);
	const REAL t4(pt.x*pt.x);
	const REAL t7(k1*(t2+t4));
	const REAL t9(1.0/t7);
	const REAL t10(t2*t9*y*0.5);
	const REAL t11(t3*t9*t9*(0.25+t9/27.0));
	#ifndef _RELEASE
	TPoint2<TYPE> upt;
	#endif
	if (k1 > 0) {
		const REAL t17(CBRT(t10+SQRT(t11)));
		const REAL t18(t17-t2*t9/(t17*3));
		#ifndef _RELEASE
		upt =
		#else
		return
		#endif
			TPoint2<TYPE>(TYPE(t18*pt.x/y), TYPE(t18));
	} else {
		ASSERT(t11 <= 0);
		const std::complex<REAL> t16(t10, SQRT(-t11));
		const std::complex<REAL> t17(pow(t16, 1.0/3.0));
		const std::complex<REAL> t14((t2*t9)/(t17*3.0));
		const std::complex<REAL> t18((t17+t14)*std::complex<REAL>(0.0,SQRT_3));
		const std::complex<REAL> t19(0.5*(t14-t17-t18));
		#ifndef _RELEASE
		upt =
		#else
		return
		#endif
			TPoint2<TYPE>(TYPE(t19.real()*pt.x/y), TYPE(t19.real()));
	}
	#ifndef _RELEASE
	ASSERT(ABS(TYPE((1.0+k1*(upt.x*upt.x+upt.y*upt.y))*upt.x) - pt.x) < TYPE(0.001));
	ASSERT(ABS(TYPE((1.0+k1*(upt.x*upt.x+upt.y*upt.y))*upt.y) - pt.y) < TYPE(0.001));
	return upt;
	#endif
}

void UndistortImage(const Camera& camera, const REAL& k1, const Image8U3 imgIn, Image8U3& imgOut)
{
	// allocate the undistorted image
	if (imgOut.data == imgIn.data ||
		imgOut.cols != imgIn.cols ||
		imgOut.rows != imgIn.rows ||
		imgOut.type() != imgIn.type())
		imgOut = Image8U3(imgIn.rows, imgIn.cols);

	// compute each pixel
	const int w = imgIn.cols;
	const int h = imgIn.rows;
	const Matrix3x3f K(camera.K);
	const Matrix3x3f invK(camera.GetInvK());
	ASSERT(ISEQUAL(K(0,2),0.5f*(w-1)) && ISEQUAL(K(1,2),0.5f*(h-1)));
	typedef Sampler::Cubic<float> Sampler;
	const Sampler sampler;
	Point2f pt;
	for (int v=0; v<h; ++v) {
		for (int u=0; u<w; ++u) {
			// compute corresponding coordinates in the distorted image
			pt.x = (float)u; pt.y = (float)v;
			NormalizeProjection(invK.val, pt.ptr(), pt.ptr());
			pt = DistortPointR1(pt, k1);
			NormalizeProjection(K.val, pt.ptr(), pt.ptr());

			// if coordinates in range
			Pixel8U& col = imgOut(v,u);
			if (imgIn.isInside(pt)) {
				// get pixel color
				col = imgIn.sample<Sampler,Pixel32F>(sampler, pt).cast<uint8_t>();
			} else {
				// set to black
				col = Pixel8U::BLACK;
			}
		}
	}
}
} // namespace MVS


bool ExportSceneVSFM()
{
	TD_TIMER_START();

	// read MVS input data
	MVS::Scene scene(OPT::nMaxThreads);
	if (!scene.Load(MAKE_PATH_SAFE(OPT::strInputFileName)))
		return false;

	// convert and write data from OpenMVS to VisualSFM
	std::vector<PBA::Camera> cameras;
	std::vector<PBA::Point3D> vertices;
	std::vector<PBA::Point2D> measurements; // the array of 2D projections (only inliers)
	std::vector<int> correspondingPoint; // 3D point index corresponding to each 2D projection
	std::vector<int> correspondingView; // and camera index
	std::vector<std::string> names;
	std::vector<int> ptc;
	cameras.reserve(scene.images.size());
	names.reserve(scene.images.size());
	MVS::IIndexArr mapIdx(scene.images.size());
	bool bFocalWarning(false), bPrincipalpointWarning(false);
	FOREACH(idx, scene.images) {
		const MVS::Image& image = scene.images[idx];
		if (!image.IsValid()) {
			mapIdx[idx] = NO_ID;
			continue;
		}
		if (!bFocalWarning && !ISEQUAL(image.camera.K(0, 0), image.camera.K(1, 1))) {
			DEBUG("warning: fx != fy and NVM format does not support it");
			bFocalWarning = true;
		}
		if (!bPrincipalpointWarning && (!ISEQUAL(REAL(image.width-1)*0.5, image.camera.K(0, 2)) || !ISEQUAL(REAL(image.height-1)*0.5, image.camera.K(1, 2)))) {
			DEBUG("warning: cx, cy are not the image center and NVM format does not support it");
			bPrincipalpointWarning = true;
		}
		PBA::Camera cameraNVM;
		cameraNVM.SetFocalLength((image.camera.K(0, 0) + image.camera.K(1, 1)) * 0.5);
		cameraNVM.SetMatrixRotation(image.camera.R.val);
		cameraNVM.SetCameraCenterAfterRotation(image.camera.C.ptr());
		mapIdx[idx] = static_cast<MVS::IIndex>(cameras.size());
		cameras.emplace_back(cameraNVM);
		names.emplace_back(MAKE_PATH_REL(WORKING_FOLDER_FULL, image.name));
	}
	vertices.reserve(scene.pointcloud.points.size());
	measurements.reserve(scene.pointcloud.pointViews.size());
	correspondingPoint.reserve(scene.pointcloud.pointViews.size());
	correspondingView.reserve(scene.pointcloud.pointViews.size());
	FOREACH(idx, scene.pointcloud.points) {
		const MVS::PointCloud::Point& X = scene.pointcloud.points[idx];
		const MVS::PointCloud::ViewArr& views = scene.pointcloud.pointViews[idx];
		const size_t prevMeasurements(measurements.size());
		for (MVS::IIndex idxView: views) {
			const MVS::Image& image = scene.images[idxView];
			const Point2f pt(image.camera.TransformPointW2I(Cast<REAL>(X)));
			if (pt.x < 0 || pt.y < 0 || pt.x > image.width-1 || pt.y > image.height-1)
				continue;
			measurements.emplace_back(pt.x, pt.y);
			correspondingView.emplace_back(static_cast<int>(mapIdx[idxView]));
			correspondingPoint.emplace_back(static_cast<int>(vertices.size()));
		}
		if (prevMeasurements < measurements.size())
			vertices.emplace_back(PBA::Point3D{X.x, X.y, X.z});
	}
	if (!scene.pointcloud.colors.empty()) {
		ptc.reserve(scene.pointcloud.colors.size()*3);
		FOREACH(idx, scene.pointcloud.points) {
			const MVS::PointCloud::Color& c = scene.pointcloud.colors[idx];
			ptc.emplace_back(c.r);
			ptc.emplace_back(c.g);
			ptc.emplace_back(c.b);
		}
	}
	PBA::SaveModelFile(MAKE_PATH_SAFE(OPT::strOutputFileName), cameras, vertices, measurements, correspondingPoint, correspondingView, names, ptc);

	VERBOSE("Input data exported: %u images & %u points (%s)", scene.images.size(), scene.pointcloud.GetSize(), TD_TIMER_GET_FMT().c_str());
	return true;
}


bool ImportSceneVSFM()
{
	TD_TIMER_START();

	// read VisualSFM input data
	std::vector<PBA::Camera> cameras;
	std::vector<PBA::Point3D> vertices;
	std::vector<PBA::Point2D> measurements; // the array of 2D projections (only inliers)
	std::vector<int> correspondingPoint; // 3D point index corresponding to each 2D projection
	std::vector<int> correspondingView; // and camera index
	std::vector<std::string> names;
	std::vector<int> ptc;
	if (!PBA::LoadModelFile(MAKE_PATH_SAFE(OPT::strInputFileName), cameras, vertices, measurements, correspondingPoint, correspondingView, names, ptc))
		return false;

	// convert data from VisualSFM to OpenMVS
	MVS::Scene scene(OPT::nMaxThreads);
	scene.platforms.Reserve((uint32_t)cameras.size());
	scene.images.Reserve((MVS::IIndex)cameras.size());
	scene.nCalibratedImages = 0;
	for (size_t idx=0; idx<cameras.size(); ++idx) {
		MVS::Image& image = scene.images.AddEmpty();
		image.name = names[idx];
		Util::ensureUnifySlash(image.name);
		image.name = MAKE_PATH_FULL(WORKING_FOLDER_FULL, image.name);
		if (!image.ReloadImage(0, false)) {
			LOG("error: can not read image %s", image.name.c_str());
			return false;
		}
		// set camera
		image.platformID = scene.platforms.GetSize();
		MVS::Platform& platform = scene.platforms.AddEmpty();
		MVS::Platform::Camera& camera = platform.cameras.AddEmpty();
		image.cameraID = 0;
		image.ID = static_cast<MVS::IIndex>(idx);
		const PBA::Camera& cameraNVM = cameras[idx];
		camera.K = MVS::Platform::Camera::ComposeK<REAL,REAL>(cameraNVM.GetFocalLength(), cameraNVM.GetFocalLength(), image.width, image.height);
		camera.R = RMatrix::IDENTITY;
		camera.C = CMatrix::ZERO;
		// normalize camera intrinsics
		camera.K = camera.GetScaledK(REAL(1)/MVS::Camera::GetNormalizationScale(image.width, image.height));
		// set pose
		image.poseID = platform.poses.GetSize();
		MVS::Platform::Pose& pose = platform.poses.AddEmpty();
		cameraNVM.GetMatrixRotation(pose.R.val);
		cameraNVM.GetCameraCenter(pose.C.ptr());
		image.UpdateCamera(scene.platforms);
		++scene.nCalibratedImages;
	}
	scene.pointcloud.points.Reserve(vertices.size());
	for (size_t idx=0; idx<vertices.size(); ++idx) {
		const PBA::Point3D& X = vertices[idx];
		scene.pointcloud.points.AddConstruct(X.xyz[0], X.xyz[1], X.xyz[2]);
	}
	scene.pointcloud.pointViews.Resize(vertices.size());
	for (size_t idx=0; idx<measurements.size(); ++idx) {
		MVS::PointCloud::ViewArr& views = scene.pointcloud.pointViews[correspondingPoint[idx]];
		views.InsertSort(correspondingView[idx]);
	}
	if (ptc.size() == vertices.size()*3) {
		scene.pointcloud.colors.Reserve(ptc.size());
		for (size_t idx=0; idx<ptc.size(); idx+=3)
			scene.pointcloud.colors.AddConstruct((uint8_t)ptc[idx+0], (uint8_t)ptc[idx+1], (uint8_t)ptc[idx+2]);
	}

	// undistort images
	const String pathData(MAKE_PATH_FULL(WORKING_FOLDER_FULL, OPT::strOutputImageFolder));
	Util::Progress progress(_T("Processed images"), scene.images.GetSize());
	#ifdef _USE_OPENMP
	bool bAbort(false);
	#pragma omp parallel for shared(bAbort) schedule(dynamic)
	for (int i=0; i<(int)scene.images.GetSize(); ++i) {
		#pragma omp flush (bAbort)
		if (bAbort)
			continue;
	#else
	FOREACH(i, scene.images) {
	#endif
		++progress;
		MVS::Image& imageData = scene.images[i];
		const PBA::Camera& cameraNVM = cameras[i];
		if (cameraNVM.GetMeasurementDistortion() == 0)
			continue;
		if (!imageData.ReloadImage()) {
			#ifdef _USE_OPENMP
			bAbort = true;
			#pragma omp flush (bAbort)
			continue;
			#else
			return false;
			#endif
		}
		MVS::UndistortImage(imageData.camera, cameraNVM.GetNormalizedMeasurementDistortion(), imageData.image, imageData.image);
		const String name(pathData + String::FormatString(_T("%05u.png"), i));
		Util::ensureFolder(name);
		if (!imageData.image.Save(name)) {
			#ifdef _USE_OPENMP
			bAbort = true;
			#pragma omp flush (bAbort)
			continue;
			#else
			return false;
			#endif
		}
		imageData.ReleaseImage();
	}
	#ifdef _USE_OPENMP
	if (bAbort)
		return false;
	#endif
	progress.close();

	VERBOSE("Input data imported: %u cameras, %u poses, %u images, %u points (%s)", cameras.size(), cameras.size(), cameras.size(), vertices.size(), TD_TIMER_GET_FMT().c_str());

	// write OpenMVS input data
	return scene.SaveInterface(MAKE_PATH_SAFE(OPT::strOutputFileName));
}


template <typename T>
void _ImageListParseP(const LPSTR* argv, TMatrix<T,3,4>& P)
{
	// read projection matrix
	P(0,0) = String::FromString<T>(argv[0]);
	P(0,1) = String::FromString<T>(argv[1]);
	P(0,2) = String::FromString<T>(argv[2]);
	P(0,3) = String::FromString<T>(argv[3]);
	P(1,0) = String::FromString<T>(argv[4]);
	P(1,1) = String::FromString<T>(argv[5]);
	P(1,2) = String::FromString<T>(argv[6]);
	P(1,3) = String::FromString<T>(argv[7]);
	P(2,0) = String::FromString<T>(argv[8]);
	P(2,1) = String::FromString<T>(argv[9]);
	P(2,2) = String::FromString<T>(argv[10]);
	P(2,3) = String::FromString<T>(argv[11]);
}

int ImportSceneCMPMVS()
{
	TD_TIMER_START();

	MVS::Scene scene(OPT::nMaxThreads);

	// read CmpMVS input data as a list of images and their projection matrices
	std::ifstream iFilein(MAKE_PATH_SAFE(OPT::strInputFileName));
	if (!iFilein.is_open())
		return false;
	while (iFilein.good()) {
		String strImageName;
		std::getline(iFilein, strImageName);
		if (strImageName.empty())
			continue;
		if (!File::access(MAKE_PATH_SAFE(strImageName)))
			return false;
		const String strImageNameP(Util::getFileFullName(strImageName)+"_P.txt");
		std::ifstream iFileP(MAKE_PATH_SAFE(strImageNameP));
		if (!iFileP.is_open())
			return false;
		String strP; int numLines(0);
		while (iFileP.good()) {
			String line;
			std::getline(iFileP, line);
			if (strImageName.empty())
				break;
			if (strP.empty())
				strP = line;
			else
				strP += _T(' ') + line;
			++numLines;
		}
		if (numLines != 3)
			return false;
		PMatrix P;
		size_t argc;
		CAutoPtrArr<LPSTR> argv(Util::CommandLineToArgvA(strP, argc));
		if (argc != 12)
			return false;
		_ImageListParseP(argv, P);
		KMatrix K; RMatrix R; CMatrix C;
		MVS::DecomposeProjectionMatrix(P, K, R, C);
		// set image
		MVS::Image& image = scene.images.AddEmpty();
		image.name = strImageName;
		Util::ensureUnifySlash(image.name);
		image.name = MAKE_PATH_FULL(WORKING_FOLDER_FULL, image.name);
		if (!image.ReloadImage(0, false)) {
			LOG("error: can not read image %s", image.name.c_str());
			return false;
		}
		// set camera
		image.platformID = scene.platforms.GetSize();
		MVS::Platform& platform = scene.platforms.AddEmpty();
		MVS::Platform::Camera& camera = platform.cameras.AddEmpty();
		image.cameraID = 0;
		camera.K = K;
		camera.R = RMatrix::IDENTITY;
		camera.C = CMatrix::ZERO;
		// normalize camera intrinsics
		camera.K = camera.GetScaledK(REAL(1)/MVS::Camera::GetNormalizationScale(image.width, image.height));
		// set pose
		image.poseID = platform.poses.GetSize();
		MVS::Platform::Pose& pose = platform.poses.AddEmpty();
		pose.R = R;
		pose.C = C;
		image.UpdateCamera(scene.platforms);
		++scene.nCalibratedImages;
	}

	VERBOSE("Input data imported: %u images (%s)", scene.images.size(), TD_TIMER_GET_FMT().c_str());

	// write OpenMVS input data
	return scene.SaveInterface(MAKE_PATH_SAFE(OPT::strOutputFileName));
}


int main(int argc, LPCTSTR* argv)
{
	#ifdef _DEBUGINFO
	// set _crtBreakAlloc index to stop in <dbgheap.c> at allocation
	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);// | _CRTDBG_CHECK_ALWAYS_DF);
	#endif

	Application application;
	if (!application.Initialize(argc, argv))
		return EXIT_FAILURE;

	if (OPT::IsFromOpenMVS) {
		ExportSceneVSFM();
	} else {
		const String strInputFileNameExt(Util::getFileExt(OPT::strInputFileName).ToLower());
		if (strInputFileNameExt == VSFM_EXT || strInputFileNameExt == BUNDLE_EXT) {
			if (!ImportSceneVSFM())
				return EXIT_FAILURE;
		} else
		if (strInputFileNameExt == CMPMVS_EXT) {
			if (!ImportSceneCMPMVS())
				return EXIT_FAILURE;
		}
	}

	return EXIT_SUCCESS;
}
/*----------------------------------------------------------------*/