int main(int argc, char* argv[])
{
// parse arguments
const char* optstring = "hr";
int c;
bool reverse = false;
while ((c = getopt (argc, argv, optstring)) != -1)
{
switch (c)
{
case 'h':
usage(hugin_utils::stripPath(argv[0]).c_str());
return 0;
case 'r':
reverse = true;
break;
case '?':
break;
default:
abort ();
}
}
if (argc - optind < 1 || argc - optind > 2)
{
usage(hugin_utils::stripPath(argv[0]).c_str());
return 1;
}
std::string input=argv[optind];
HuginBase::Panorama pano;
std::ifstream prjfile(input.c_str());
if (!prjfile.good())
{
std::cerr << "could not open script : " << input << std::endl;
return 1;
}
pano.setFilePrefix(hugin_utils::getPathPrefix(input));
AppBase::DocumentData::ReadWriteError err = pano.readData(prjfile);
if (err != AppBase::DocumentData::SUCCESSFUL)
{
std::cerr << "error while parsing panos tool script: " << input << std::endl;
std::cerr << "AppBase::DocumentData::ReadWriteError code: " << err << std::endl;
return 1;
}
// set up output format
std::cout.setf ( std::ios::fixed ) ;
std::cout.precision ( 6 ) ; // should be ample
if ( argc - optind == 1 )
{
// no image number was passed. This triggers the new
// behaviour to accept triplets on cin
work_on_triplets ( pano , reverse ) ;
return 0;
}
// an image number was passed, so proceed
// as in the original version
int imageNumber = atoi(argv[optind+1]);
if (imageNumber >= pano.getNrOfImages())
{
std::cerr << "Not enough images in panorama" << std::endl;
return 1;
}
// pano tools interface
HuginBase::PTools::Transform trafo;
if (reverse)
{
trafo.createTransform(pano.getSrcImage(imageNumber), pano.getOptions());
}
else
{
trafo.createInvTransform(pano.getSrcImage(imageNumber), pano.getOptions());
}
double xin , yin , xout , yout ;
// here's where the old-style IO was, now it's all streams.
// It's also format-free input, so newlines don't matter
while ( std::cin >> xin >> yin )
{
trafo.transformImgCoord(xout, yout, xin, yin);
std::cout << xout << " " << yout << std::endl ;
}
}
GreatCircleArc::GreatCircleArc(double startLat, double startLong,
double endLat, double endLong,
VisualizationState & visualizationState)
{
m_visualizationState = &visualizationState;
// get the output projection
const HuginBase::PanoramaOptions & options = *(visualizationState.GetOptions());
// make an image to transform spherical coordinates into the output projection
HuginBase::SrcPanoImage equirectangularImage;
equirectangularImage.setProjection(HuginBase::SrcPanoImage::EQUIRECTANGULAR);
equirectangularImage.setHFOV(360.0);
equirectangularImage.setSize(vigra::Size2D(360.0, 180.0));
// make a transformation from spherical coordinates to the output projection
HuginBase::PTools::Transform transform;
transform.createInvTransform(equirectangularImage, options);
m_xscale = visualizationState.GetScale();
/**Handle case where the points are opposite sides of the sphere
* (i.e. The angle startLat is -endLat and startLong is -endLong.)
* There are infinetly many great circles in this case, we pick one going
* through (180, 90), by splitting the problem in two.
*/
if (startLat == 360.0 - endLat && startLong == 180.0 - endLong)
{
// we should probably check to see if we already go through (180, 90).
if (startLat == 180.0 && startLong == 90.0)
{
// foiled again: pick one going through (180, 0) instead.
*this = GreatCircleArc(startLat, startLong, 180.0, 0.0, visualizationState);
GreatCircleArc other(180.0, 0.0, endLat, endLong, visualizationState);
m_lines.insert(m_lines.end(), other.m_lines.begin(), other.m_lines.end());
return;
}
*this = GreatCircleArc(startLat, startLong, 180.0, 90.0, visualizationState);
GreatCircleArc other(180.0, 90.0, endLat, endLong, visualizationState);
m_lines.insert(m_lines.end(), other.m_lines.begin(), other.m_lines.end());
return;
}
// convert start and end positions so that they don't go across the +/-180
// degree seam
if (startLat < 90.0 && endLat > 270.0)
{
endLat -= 360.0;
}
// convert to radians
startLat *= (M_PI / 180.0);
startLong *= (M_PI / 180.0);
endLat *= (M_PI / 180.0);
endLong *= (M_PI / 180.0);
// find sines and cosines, they are used multiple times.
double sineStartLat = std::sin(startLat);
double sineStartLong = std::sin(startLong);
double sineEndLat = std::sin(endLat);
double sineEndLong = std::sin(endLong);
double cosineStartLat = std::cos(startLat);
double cosineStartLong = std::cos(startLong);
double cosineEndLat = std::cos(endLat);
double cosineEndLong = std::cos(endLong);
/* to get points on the great circle, we linearly interpolate between the
* two 3D coordinates for the given spherical coordinates, then normalise
* the vector to get back on the sphere. This works everywhere except exact
* opposite points, where we'll get the original points repeated several
* times (and if we are even more unlucky we will hit the origin where the
* normal isn't defined.)
*/
// convert locations to 3d coordinates.
double p1[3] = {cosineStartLat * sineStartLong, sineStartLat * sineStartLong, cosineStartLong};
double p2[3] = {cosineEndLat * sineEndLong, sineEndLat * sineEndLong, cosineEndLong};
///@todo don't check the +/- 180 degree boundary when projection does not break there.
bool hasSeam = true;
// draw a line strip and transform the coordinates as we go.
double b1 = 0.0;
double b2 = 1.0;
const double bDifference = 1.0 / double(segments);
// for discontinuity detection.
int lastSegment = 1;
// The last processed vertex's position.
hugin_utils::FDiff2D last_vertex;
/* true if we shouldn't use last_vertex to make a line segment
* i.e. We just crossed a discontinuity. */
bool skip = true;
for (unsigned int segment_index = 0; segment_index < segments;
segment_index++, b1 += bDifference, b2 -= bDifference)
{
// linearly interpolate positions
double v[3] = {p1[0] * b1 + p2[0] * b2, p1[1] * b1 + p2[1] * b2, p1[2] * b1 + p2[2] * b2};
// normalise
double length = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
v[0] /= length;
v[1] /= length;
v[2] /= length;
/*double longitude = atan2(numerator,
cosineStartLong * (c1 * std::sin(latitude) -
c2 * std::cos(latitude)));*/
double longitude = std::acos(v[2]);
// acos returns values between 0 and M_PI. The other
// latitudes are on the back of the sphere, so check y coordinate (v1)
double latitude = std::acos(v[0] / std::sin(longitude));
if (v[1] < 0.0)
{
// on the back.
latitude = -latitude + 2 * M_PI;
}
double vx, vy;
bool infront = transform.transformImgCoord(vx,
vy,
latitude * 180.0 / M_PI,
longitude * 180.0 / M_PI);
// don't draw across +/- 180 degree seems.
if (hasSeam)
{
// we divide the width of the panorama into 3 segments. If we jump
// across the middle section, we split the line into two.
int newSegment = vx / (options.getWidth() / 3);
if ((newSegment < 1 && lastSegment > 1) ||
(newSegment > 1 && lastSegment < 1))
{
skip = true;
}
lastSegment = newSegment;
}
if (infront)
{
if (!skip)
{
LineSegment line;
line.vertices[0] = last_vertex;
line.vertices[1] = hugin_utils::FDiff2D(vx, vy);
m_lines.push_back(line);
}
// The next line segment should be a valid one.
last_vertex = hugin_utils::FDiff2D(vx, vy);
skip = false;
} else {
skip = true;
}
}
}
