int main(int argc, char *argv[])
{
// parse arguments
const char * optstring = "alho:npqsv:m";
int c;
string output;
bool doPairwise = false;
bool doAutoOpt = false;
bool doNormalOpt = false;
bool doLevel = false;
bool chooseProj = false;
bool quiet = false;
bool doPhotometric = false;
double hfov = 0.0;
while ((c = getopt (argc, argv, optstring)) != -1)
{
switch (c) {
case 'o':
output = optarg;
break;
case 'h':
usage(argv[0]);
return 0;
case 'p':
doPairwise = true;
break;
case 'a':
doAutoOpt = true;
break;
case 'n':
doNormalOpt = true;
break;
case 'l':
doLevel = true;
break;
case 's':
chooseProj = true;
break;
case 'q':
quiet = true;
break;
case 'v':
hfov = atof(optarg);
break;
case 'm':
doPhotometric = true;
break;
default:
abort ();
}
}
if (argc - optind != 1) {
usage(argv[0]);
return 1;
}
const char * scriptFile = argv[optind];
Panorama pano;
if (scriptFile[0] == '-') {
DocumentData::ReadWriteError err = pano.readData(std::cin);
if (err != DocumentData::SUCCESSFUL) {
cerr << "error while reading script file from stdin." << endl;
cerr << "DocumentData::ReadWriteError code: " << err << endl;
return 1;
}
} else {
ifstream prjfile(scriptFile);
if (!prjfile.good()) {
cerr << "could not open script : " << scriptFile << endl;
return 1;
}
pano.setFilePrefix(hugin_utils::getPathPrefix(scriptFile));
DocumentData::ReadWriteError err = pano.readData(prjfile);
if (err != DocumentData::SUCCESSFUL) {
cerr << "error while parsing panos tool script: " << scriptFile << endl;
cerr << "DocumentData::ReadWriteError code: " << err << endl;
return 1;
}
}
if (pano.getNrOfImages() == 0) {
cerr << "Panorama should consist of at least one image" << endl;
return 1;
}
// for bad HFOV (from autopano-SIFT)
for (unsigned i=0; i < pano.getNrOfImages(); i++) {
SrcPanoImage img = pano.getSrcImage(i);
if (img.getProjection() == SrcPanoImage::RECTILINEAR
&& img.getHFOV() >= 180)
{
// something is wrong here, try to read from exif data
double focalLength = 0;
double cropFactor = 0;
cerr << "HFOV of image " << img.getFilename() << " invalid, trying to read EXIF tags" << endl;
bool ok = img.readEXIF(focalLength, cropFactor, true, false);
if (! ok) {
if (hfov) {
img.setHFOV(hfov);
} else {
cerr << "EXIF reading failed, please specify HFOV with -v" << endl;
return 1;
}
}
pano.setSrcImage(i, img);
}
}
if(pano.getNrOfCtrlPoints()==0 && (doPairwise || doAutoOpt || doNormalOpt))
{
cerr << "Panorama have to have control points to optimise positions" << endl;
return 1;
};
if (doPairwise && ! doAutoOpt) {
// do pairwise optimisation
set<string> optvars;
optvars.insert("r");
optvars.insert("p");
optvars.insert("y");
AutoOptimise::autoOptimise(pano);
// do global optimisation
if (!quiet) std::cerr << "*** Pairwise position optimisation" << endl;
PTools::optimize(pano);
} else if (doAutoOpt) {
if (!quiet) std::cerr << "*** Adaptive geometric optimisation" << endl;
SmartOptimise::smartOptimize(pano);
} else if (doNormalOpt) {
if (!quiet) std::cerr << "*** Optimising parameters specified in PTO file" << endl;
PTools::optimize(pano);
} else {
if (!quiet) std::cerr << "*** Geometric parameters not optimized" << endl;
}
if (doLevel)
{
bool hasVerticalLines=false;
CPVector allCP=pano.getCtrlPoints();
if(allCP.size()>0 && (doPairwise || doAutoOpt || doNormalOpt))
{
for(size_t i=0;i<allCP.size() && !hasVerticalLines;i++)
{
hasVerticalLines=(allCP[i].mode==ControlPoint::X);
};
};
// straighten only if there are no vertical control points
if(hasVerticalLines)
{
cout << "Skipping automatic leveling because of existing vertical control points." << endl;
}
else
{
StraightenPanorama(pano).run();
CenterHorizontally(pano).run();
};
}
if (chooseProj) {
PanoramaOptions opts = pano.getOptions();
double hfov, vfov;
CalculateFitPanorama fitPano = CalculateFitPanorama(pano);
fitPano.run();
opts.setHFOV(fitPano.getResultHorizontalFOV());
opts.setHeight(roundi(fitPano.getResultHeight()));
vfov = opts.getVFOV();
hfov = opts.getHFOV();
// avoid perspective projection if field of view > 100 deg
double mf = 100;
if (vfov < mf) {
// cylindrical or rectilinear
if (hfov < mf) {
opts.setProjection(PanoramaOptions::RECTILINEAR);
} else {
opts.setProjection(PanoramaOptions::CYLINDRICAL);
}
}
// downscale pano a little
double sizeFactor = 0.7;
pano.setOptions(opts);
double w = CalculateOptimalScale::calcOptimalScale(pano);
opts.setWidth(roundi(opts.getWidth()*w*sizeFactor), true);
pano.setOptions(opts);
}
if(doPhotometric)
{
// photometric estimation
PanoramaOptions opts = pano.getOptions();
int nPoints = 200;
int pyrLevel=3;
bool randomPoints = true;
nPoints = nPoints * pano.getNrOfImages();
std::vector<vigra_ext::PointPairRGB> points;
ProgressDisplay *progressDisplay;
if(!quiet)
progressDisplay=new StreamProgressDisplay(std::cout);
else
progressDisplay=new DummyProgressDisplay();
try
{
loadImgsAndExtractPoints(pano, nPoints, pyrLevel, randomPoints, *progressDisplay, points, !quiet);
}
catch (std::exception & e)
{
cerr << "caught exception: " << e.what() << endl;
return 1;
};
if(!quiet)
cout << "\rSelected " << points.size() << " points" << endl;
if (points.size() == 0)
{
cerr << "Error: no overlapping points found, exiting" << endl;
return 1;
}
progressDisplay->startSubtask("Photometric Optimization", 0.0);
// first, ensure that vignetting and response coefficients are linked
const HuginBase::ImageVariableGroup::ImageVariableEnum vars[] = {
HuginBase::ImageVariableGroup::IVE_EMoRParams,
HuginBase::ImageVariableGroup::IVE_ResponseType,
HuginBase::ImageVariableGroup::IVE_VigCorrMode,
HuginBase::ImageVariableGroup::IVE_RadialVigCorrCoeff,
HuginBase::ImageVariableGroup::IVE_RadialVigCorrCenterShift
};
HuginBase::StandardImageVariableGroups variable_groups(pano);
HuginBase::ImageVariableGroup & lenses = variable_groups.getLenses();
for (size_t i = 0; i < lenses.getNumberOfParts(); i++)
{
std::set<HuginBase::ImageVariableGroup::ImageVariableEnum> links_needed;
links_needed.clear();
for (int v = 0; v < 5; v++)
{
if (!lenses.getVarLinkedInPart(vars[v], i))
{
links_needed.insert(vars[v]);
}
};
if (!links_needed.empty())
{
std::set<HuginBase::ImageVariableGroup::ImageVariableEnum>::iterator it;
for (it = links_needed.begin(); it != links_needed.end(); it++)
{
lenses.linkVariablePart(*it, i);
}
}
}
HuginBase::SmartPhotometricOptimizer::PhotometricOptimizeMode optmode =
HuginBase::SmartPhotometricOptimizer::OPT_PHOTOMETRIC_LDR;
if (opts.outputMode == PanoramaOptions::OUTPUT_HDR)
{
optmode = HuginBase::SmartPhotometricOptimizer::OPT_PHOTOMETRIC_HDR;
}
SmartPhotometricOptimizer photoOpt(pano, progressDisplay, pano.getOptimizeVector(), points, optmode);
photoOpt.run();
// calculate the mean exposure.
opts.outputExposureValue = CalculateMeanExposure::calcMeanExposure(pano);
pano.setOptions(opts);
progressDisplay->finishSubtask();
delete progressDisplay;
};
// write result
OptimizeVector optvec = pano.getOptimizeVector();
UIntSet imgs;
fill_set(imgs,0, pano.getNrOfImages()-1);
if (output != "") {
ofstream of(output.c_str());
pano.printPanoramaScript(of, optvec, pano.getOptions(), imgs, false, hugin_utils::getPathPrefix(scriptFile));
} else {
pano.printPanoramaScript(cout, optvec, pano.getOptions(), imgs, false, hugin_utils::getPathPrefix(scriptFile));
}
return 0;
}
bool PanoDetector::loadProject()
{
ifstream ptoFile(_inputFile.c_str());
if (ptoFile.bad())
{
cerr << "ERROR: could not open file: '" << _inputFile << "'!" << endl;
return false;
}
_prefix=hugin_utils::getPathPrefix(_inputFile);
if(_prefix.empty())
{
// Get the current working directory:
char* buffer;
#ifdef _WINDOWS
#define getcwd _getcwd
#endif
if((buffer=getcwd(NULL,0))!=NULL)
{
_prefix.append(buffer);
free(buffer);
_prefix=includeTrailingPathSep(_prefix);
}
};
_panoramaInfo->setFilePrefix(_prefix);
AppBase::DocumentData::ReadWriteError err = _panoramaInfo->readData(ptoFile);
if (err != AppBase::DocumentData::SUCCESSFUL)
{
cerr << "ERROR: couldn't parse panos tool script: '" << _inputFile << "'!" << endl;
return false;
}
// Create a copy of panoramaInfo that will be used to define
// image options
_panoramaInfoCopy=_panoramaInfo->duplicate();
// Add images found in the project file to _filesData
unsigned int nImg = _panoramaInfo->getNrOfImages();
unsigned int imgWithKeyfile=0;
for (unsigned int imgNr = 0; imgNr < nImg; ++imgNr)
{
// insert the image in the map
_filesData.insert(make_pair(imgNr, ImgData()));
// get the data
ImgData& aImgData = _filesData[imgNr];
// get a copy of image info
SrcPanoImage img = _panoramaInfoCopy.getSrcImage(imgNr);
// set the name
aImgData._name = img.getFilename();
// modify image position in the copy
img.setYaw(0);
img.setRoll(0);
img.setPitch(0);
img.setX(0);
img.setY(0);
img.setZ(0);
img.setActive(true);
img.setResponseType(SrcPanoImage::RESPONSE_LINEAR);
img.setExposureValue(0);
_panoramaInfoCopy.setImage(imgNr,img);
// Number pointing to image info in _panoramaInfo
aImgData._number = imgNr;
aImgData._needsremap=(img.getHFOV()>=65 && img.getProjection() != SrcPanoImage::FISHEYE_STEREOGRAPHIC);
// set image detection size
if(aImgData._needsremap)
{
_filesData[imgNr]._detectWidth = max(img.getSize().width(),img.getSize().height());
_filesData[imgNr]._detectHeight = max(img.getSize().width(),img.getSize().height());
}
else
{
_filesData[imgNr]._detectWidth = img.getSize().width();
_filesData[imgNr]._detectHeight = img.getSize().height();
};
if (_downscale)
{
_filesData[imgNr]._detectWidth >>= 1;
_filesData[imgNr]._detectHeight >>= 1;
}
// set image remapping options
if(aImgData._needsremap)
{
aImgData._projOpts.setProjection(PanoramaOptions::STEREOGRAPHIC);
aImgData._projOpts.setHFOV(250);
aImgData._projOpts.setVFOV(250);
aImgData._projOpts.setWidth(250);
aImgData._projOpts.setHeight(250);
// determine size of output image.
// The old code did not work with images with images with a FOV
// approaching 180 degrees
vigra::Rect2D roi=estimateOutputROI(_panoramaInfoCopy,aImgData._projOpts,imgNr);
double scalefactor = max((double)_filesData[imgNr]._detectWidth / roi.width(),
(double)_filesData[imgNr]._detectHeight / roi.height() );
// resize output canvas
vigra::Size2D canvasSize((int)aImgData._projOpts.getWidth() * scalefactor,
(int)aImgData._projOpts.getHeight() * scalefactor);
aImgData._projOpts.setWidth(canvasSize.width(), false);
aImgData._projOpts.setHeight(canvasSize.height());
// set roi to cover the remapped input image
roi = roi * scalefactor;
_filesData[imgNr]._detectWidth = roi.width();
_filesData[imgNr]._detectHeight = roi.height();
aImgData._projOpts.setROI(roi);
}
// Specify if the image has an associated keypoint file
aImgData._keyfilename = getKeyfilenameFor(_keypath,aImgData._name);
ifstream keyfile(aImgData._keyfilename.c_str());
aImgData._hasakeyfile = keyfile.good();
if(aImgData._hasakeyfile)
{
imgWithKeyfile++;
};
}
//update masks, convert positive masks into negative masks
//because positive masks works only if the images are on the final positions
_panoramaInfoCopy.updateMasks(true);
//if all images has keyfile, we don't need to load celeste model file
if(nImg==imgWithKeyfile)
{
_celeste=false;
};
return true;
}
CPVector AutoPanoSift::automatch(CPDetectorSetting &setting, PT::Panorama & pano, const PT::UIntSet & imgs,
int nFeatures, vector<wxString> &keyFiles, int & ret_value, wxWindow *parent)
{
CPVector cps;
if (imgs.size() == 0)
{
return cps;
}
DEBUG_ASSERT(keyFiles.size()==pano.getNrOfImages());
// create suitable command line..
wxString generateKeysExe=GetProgPath(setting.GetProg());
wxString matcherExe = GetProgPath(setting.GetProgMatcher());
wxString generateKeysArgs=setting.GetArgs();
wxString matcherArgs = setting.GetArgsMatcher();
wxString tempDir= wxConfigBase::Get()->Read(wxT("tempDir"),wxT(""));
if(!tempDir.IsEmpty())
if(tempDir.Last()!=wxFileName::GetPathSeparator())
tempDir.Append(wxFileName::GetPathSeparator());
//check arguments
if(generateKeysArgs.Find(wxT("%i"))==wxNOT_FOUND || generateKeysArgs.Find(wxT("%k"))==wxNOT_FOUND)
{
CPMessage(_("Please use %i to specify the input files and %k to specify the keypoint file for the generate keys step"),
_("Error in control point detector command"), parent);
return cps;
};
if(matcherArgs.Find(wxT("%k"))==wxNOT_FOUND || matcherArgs.Find(wxT("%o"))==wxNOT_FOUND)
{
CPMessage(_("Please use %k to specify the keypoint files and %o to specify the output project file for the matching step"),
_("Error in control point detector command"), parent);
return cps;
};
ret_value=0;
for(UIntSet::const_iterator img=imgs.begin();img!=imgs.end();img++)
{
if(keyFiles[*img].IsEmpty())
{
//no key files exists, so generate it
wxString keyfile=wxFileName::CreateTempFileName(tempDir+wxT("apk_"));
keyFiles[*img]=keyfile;
wxString cmd=generateKeysArgs;
wxString tmp;
tmp.Printf(wxT("%d"), nFeatures);
cmd.Replace(wxT("%p"), tmp);
SrcPanoImage srcImg = pano.getSrcImage(*img);
tmp.Printf(wxT("%f"), srcImg.getHFOV());
cmd.Replace(wxT("%v"), tmp);
tmp.Printf(wxT("%d"), (int) srcImg.getProjection());
cmd.Replace(wxT("%f"), tmp);
cmd.Replace(wxT("%i"),wxQuoteFilename(wxString(srcImg.getFilename().c_str(), HUGIN_CONV_FILENAME)));
cmd.Replace(wxT("%k"),wxQuoteFilename(keyfile));
// use MyExternalCmdExecDialog
ret_value = CPExecute(generateKeysExe, cmd, _("generating key file"), parent);
cmd=generateKeysExe+wxT(" ")+cmd;
if (ret_value == HUGIN_EXIT_CODE_CANCELLED)
return cps;
else
if (ret_value == -1)
{
CPMessage( wxString::Format(_("Could not execute command: %s"),cmd.c_str()), _("wxExecute Error"), parent);
return cps;
}
else
if (ret_value > 0)
{
CPMessage(wxString::Format(_("Command: %s\nfailed with error code: %d"),cmd.c_str(),ret_value),
_("wxExecute Error"), parent);
return cps;
};
};
};
// TODO: create a secure temporary filename here
wxString ptofile = wxFileName::CreateTempFileName(wxT("ap_res"));
matcherArgs.Replace(wxT("%o"), ptofile);
wxString tmp;
tmp.Printf(wxT("%d"), nFeatures);
matcherArgs.Replace(wxT("%p"), tmp);
SrcPanoImage firstImg = pano.getSrcImage(*imgs.begin());
tmp.Printf(wxT("%f"), firstImg.getHFOV());
matcherArgs.Replace(wxT("%v"), tmp);
tmp.Printf(wxT("%d"), (int) firstImg.getProjection());
matcherArgs.Replace(wxT("%f"), tmp);
wxString imgFiles;
for(UIntSet::const_iterator it = imgs.begin(); it != imgs.end(); it++)
{
imgFiles.append(wxT(" ")).append(wxQuoteFilename(keyFiles[*it]));
};
matcherArgs.Replace(wxT("%k"), wxString (imgFiles.wc_str(), HUGIN_CONV_FILENAME));
#ifdef __WXMSW__
if (matcherArgs.size() > 32000) {
CPMessage(_("Command line for control point detector too long.\nThis is a Windows limitation\nPlease select less images, or place the images in a folder with\na shorter pathname"),
_("Too many images selected"), parent );
return cps;
}
#endif
wxString cmd = matcherExe + wxT(" ") + matcherArgs;
DEBUG_DEBUG("Executing: " << matcherExe.mb_str(wxConvLocal) << " " << matcherArgs.mb_str(wxConvLocal));
wxArrayString arguments = wxCmdLineParser::ConvertStringToArgs(matcherArgs);
if (arguments.GetCount() > 127) {
DEBUG_ERROR("Too many arguments for call to wxExecute()");
CPMessage(wxString::Format(_("Too many arguments (images). Try using a cp generator setting which supports the %%s parameter in preferences.\n\n Could not execute command: %s"), matcherExe.c_str()), _("wxExecute Error"), parent);
return cps;
}
// use MyExternalCmdExecDialog
ret_value = CPExecute(matcherExe, matcherArgs, _("finding control points"), parent);
if (ret_value == HUGIN_EXIT_CODE_CANCELLED)
return cps;
else
if (ret_value == -1)
{
CPMessage( wxString::Format(_("Could not execute command: %s"),cmd.c_str()), _("wxExecute Error"), parent);
return cps;
}
else
if (ret_value > 0)
{
CPMessage(wxString::Format(_("Command: %s\nfailed with error code: %d"),cmd.c_str(),ret_value),
_("wxExecute Error"), parent);
return cps;
};
if (! wxFileExists(ptofile.c_str()))
{
CPMessage(wxString::Format(_("Could not open %s for reading\nThis is an indicator that the control point detector call failed,\nor incorrect command line parameters have been used.\n\nExecuted command: %s"),ptofile.c_str(),cmd.c_str()),
_("Control point detector failure"), parent );
return cps;
}
// read and update control points
cps = readUpdatedControlPoints((const char *)ptofile.mb_str(HUGIN_CONV_FILENAME), pano);
if (!wxRemoveFile(ptofile)) {
DEBUG_DEBUG("could not remove temporary file: " << ptofile.c_str());
}
return cps;
};
CPVector AutoPanoKolor::automatch(CPDetectorSetting &setting, Panorama & pano, const UIntSet & imgs,
int nFeatures, int & ret_value, wxWindow *parent)
{
CPVector cps;
wxString autopanoExe = setting.GetProg();
// write default autopano.kolor.com flags
wxString autopanoArgs = setting.GetArgs();
string imgFiles;
for(UIntSet::const_iterator it = imgs.begin(); it != imgs.end(); it++)
{
imgFiles.append(" ").append(quoteFilename(pano.getImage(*it).getFilename()));
}
wxString ptofilepath = wxFileName::CreateTempFileName(wxT("ap_res"));
wxFileName ptofn(ptofilepath);
wxString ptofile = ptofn.GetFullName();
autopanoArgs.Replace(wxT("%o"), ptofile);
wxString tmp;
tmp.Printf(wxT("%d"), nFeatures);
autopanoArgs.Replace(wxT("%p"), tmp);
SrcPanoImage firstImg = pano.getSrcImage(*imgs.begin());
tmp.Printf(wxT("%f"), firstImg.getHFOV());
autopanoArgs.Replace(wxT("%v"), tmp);
tmp.Printf(wxT("%d"), (int) firstImg.getProjection());
autopanoArgs.Replace(wxT("%f"), tmp);
autopanoArgs.Replace(wxT("%i"), wxString (imgFiles.c_str(), HUGIN_CONV_FILENAME));
wxString tempdir = ptofn.GetPath();
autopanoArgs.Replace(wxT("%d"), ptofn.GetPath());
wxString cmd;
cmd.Printf(wxT("%s %s"), wxQuoteFilename(autopanoExe).c_str(), autopanoArgs.c_str());
#ifdef __WXMSW__
if (cmd.size() > 32766) {
CPMessage(_("Command line for control point detector too long.\nThis is a Windows limitation\nPlease select less images, or place the images in a folder with\na shorter pathname"),
_("Too many images selected"), parent);
return cps;
}
#endif
DEBUG_DEBUG("Executing: " << cmd.c_str());
wxArrayString arguments = wxCmdLineParser::ConvertStringToArgs(cmd);
if (arguments.GetCount() > 127) {
DEBUG_ERROR("Too many arguments for call to wxExecute()");
DEBUG_ERROR("Try using the %s parameter in preferences");
CPMessage(wxString::Format(_("Too many arguments (images). Try using the %%s parameter in preferences.\n\n Could not execute command: %s"), autopanoExe.c_str()), _("wxExecute Error"), parent);
return cps;
}
ret_value = 0;
// use MyExternalCmdExecDialog
ret_value = CPExecute(autopanoExe, autopanoArgs, _("finding control points"), parent);
if (ret_value == HUGIN_EXIT_CODE_CANCELLED) {
return cps;
} else if (ret_value == -1) {
CPMessage( wxString::Format(_("Could not execute command: %s"),cmd.c_str()), _("wxExecute Error"), parent);
return cps;
} else if (ret_value > 0) {
CPMessage(wxString::Format(_("Command: %s\nfailed with error code: %d"),cmd.c_str(),ret_value),
_("wxExecute Error"), parent);
return cps;
}
ptofile = ptofn.GetFullPath();
ptofile.append(wxT("0.oto"));
if (! wxFileExists(ptofile.c_str()) ) {
CPMessage(wxString::Format(_("Could not open %s for reading\nThis is an indicator that the control point detector call failed,\nor incorrect command line parameters have been used.\n\nExecuted command: %s"),ptofile.c_str(),cmd.c_str()),
_("Control point detector failure"), parent );
return cps;
}
// read and update control points
cps = readUpdatedControlPoints((const char *)ptofile.mb_str(HUGIN_CONV_FILENAME), pano);
if (!wxRemoveFile(ptofile)) {
DEBUG_DEBUG("could not remove temporary file: " << ptofile.c_str());
}
return cps;
}
CPVector AutoPanoSift::automatch(CPDetectorSetting &setting, Panorama & pano, const UIntSet & imgs,
int nFeatures, int & ret_value, wxWindow *parent)
{
CPVector cps;
if (imgs.size() == 0) {
return cps;
}
// create suitable command line..
wxString autopanoExe = GetProgPath(setting.GetProg());
if(setting.IsTwoStepDetector())
{
std::vector<wxString> keyFiles(pano.getNrOfImages());
cps=automatch(setting, pano, imgs, nFeatures, keyFiles, ret_value, parent);
Cleanup(setting, pano, imgs, keyFiles, parent);
return cps;
};
wxString autopanoArgs = setting.GetArgs();
// TODO: create a secure temporary filename here
wxString ptofile = wxFileName::CreateTempFileName(wxT("ap_res"));
autopanoArgs.Replace(wxT("%o"), ptofile);
wxString tmp;
tmp.Printf(wxT("%d"), nFeatures);
autopanoArgs.Replace(wxT("%p"), tmp);
SrcPanoImage firstImg = pano.getSrcImage(*imgs.begin());
tmp.Printf(wxT("%f"), firstImg.getHFOV());
autopanoArgs.Replace(wxT("%v"), tmp);
tmp.Printf(wxT("%d"), (int) firstImg.getProjection());
autopanoArgs.Replace(wxT("%f"), tmp);
long idx = autopanoArgs.Find(wxT("%namefile")) ;
DEBUG_DEBUG("find %namefile in '"<< autopanoArgs.mb_str(wxConvLocal) << "' returned: " << idx);
bool use_namefile = idx >=0;
idx = autopanoArgs.Find(wxT("%i"));
DEBUG_DEBUG("find %i in '"<< autopanoArgs.mb_str(wxConvLocal) << "' returned: " << idx);
bool use_params = idx >=0;
idx = autopanoArgs.Find(wxT("%s"));
bool use_inputscript = idx >=0;
if (! (use_namefile || use_params || use_inputscript)) {
CPMessage(_("Please use %namefile, %i or %s to specify the input files for the control point detector"),
_("Error in control point detector command"), parent);
return cps;
}
wxFile namefile;
wxString namefile_name;
if (use_namefile) {
// create temporary file with image names.
namefile_name = wxFileName::CreateTempFileName(wxT("ap_imgnames"), &namefile);
DEBUG_DEBUG("before replace %namefile: " << autopanoArgs.mb_str(wxConvLocal));
autopanoArgs.Replace(wxT("%namefile"), namefile_name);
DEBUG_DEBUG("after replace %namefile: " << autopanoArgs.mb_str(wxConvLocal));
for(UIntSet::const_iterator it = imgs.begin(); it != imgs.end(); it++)
{
namefile.Write(wxString(pano.getImage(*it).getFilename().c_str(), HUGIN_CONV_FILENAME));
namefile.Write(wxT("\r\n"));
}
// close namefile
if (namefile_name != wxString(wxT(""))) {
namefile.Close();
}
} else {
string imgFiles;
for(UIntSet::const_iterator it = imgs.begin(); it != imgs.end(); it++)
{
imgFiles.append(" ").append(quoteFilename(pano.getImage(*it).getFilename()));
}
autopanoArgs.Replace(wxT("%i"), wxString (imgFiles.c_str(), HUGIN_CONV_FILENAME));
}
wxString ptoinfile_name;
if (use_inputscript) {
wxFile ptoinfile;
ptoinfile_name = wxFileName::CreateTempFileName(wxT("ap_inproj"));
autopanoArgs.Replace(wxT("%s"), ptoinfile_name);
ofstream ptoinstream(ptoinfile_name.mb_str(wxConvFile));
//delete all existing control points in temp project
//otherwise the existing control points will be loaded again
Panorama tempPano=pano.duplicate();
CPVector emptyCPV;
tempPano.setCtrlPoints(emptyCPV);
tempPano.printPanoramaScript(ptoinstream, tempPano.getOptimizeVector(), tempPano.getOptions(), imgs, false);
}
#ifdef __WXMSW__
if (autopanoArgs.size() > 32000) {
CPMessage(_("Command line for control point detector too long.\nThis is a Windows limitation\nPlease select less images, or place the images in a folder with\na shorter pathname"),
_("Too many images selected"), parent );
return cps;
}
#endif
wxString cmd = autopanoExe + wxT(" ") + autopanoArgs;
DEBUG_DEBUG("Executing: " << autopanoExe.mb_str(wxConvLocal) << " " << autopanoArgs.mb_str(wxConvLocal));
wxArrayString arguments = wxCmdLineParser::ConvertStringToArgs(autopanoArgs);
if (arguments.GetCount() > 127) {
DEBUG_ERROR("Too many arguments for call to wxExecute()");
DEBUG_ERROR("Try using the %%s parameter in preferences");
CPMessage(wxString::Format(_("Too many arguments (images). Try using the %%s parameter in preferences.\n\n Could not execute command: %s"), autopanoExe.c_str()), _("wxExecute Error"), parent);
return cps;
}
ret_value = 0;
// use MyExternalCmdExecDialog
ret_value = CPExecute(autopanoExe, autopanoArgs, _("finding control points"), parent);
if (ret_value == HUGIN_EXIT_CODE_CANCELLED) {
return cps;
} else if (ret_value == -1) {
CPMessage( wxString::Format(_("Could not execute command: %s"),cmd.c_str()), _("wxExecute Error"), parent);
return cps;
} else if (ret_value > 0) {
CPMessage(wxString::Format(_("Command: %s\nfailed with error code: %d"),cmd.c_str(),ret_value),
_("wxExecute Error"), parent);
return cps;
}
if (! wxFileExists(ptofile.c_str())) {
CPMessage(wxString::Format(_("Could not open %s for reading\nThis is an indicator that the control point detector call failed,\nor incorrect command line parameters have been used.\n\nExecuted command: %s"),ptofile.c_str(),cmd.c_str()),
_("Control point detector failure"), parent );
return cps;
}
// read and update control points
if(use_inputscript)
{
cps = readUpdatedControlPoints((const char*)ptofile.mb_str(HUGIN_CONV_FILENAME), pano, imgs);
}
else
{
cps = readUpdatedControlPoints((const char *)ptofile.mb_str(HUGIN_CONV_FILENAME), pano);
};
if (namefile_name != wxString(wxT(""))) {
namefile.Close();
wxRemoveFile(namefile_name);
}
if (ptoinfile_name != wxString(wxT(""))) {
wxRemoveFile(ptoinfile_name);
}
if (!wxRemoveFile(ptofile)) {
DEBUG_DEBUG("could not remove temporary file: " << ptofile.c_str());
}
return cps;
}