void GeoDataLineStringPrivate::toDateLineCorrected(
const GeoDataLineString & q,
QVector<GeoDataLineString*> & lineStrings
)
{
const bool isClosed = q.isClosed();
const QVector<GeoDataCoordinates>::const_iterator itStartPoint = q.constBegin();
const QVector<GeoDataCoordinates>::const_iterator itEndPoint = q.constEnd();
QVector<GeoDataCoordinates>::const_iterator itPoint = itStartPoint;
QVector<GeoDataCoordinates>::const_iterator itPreviousPoint = itPoint;
TessellationFlags f = q.tessellationFlags();
GeoDataLineString * unfinishedLineString = 0;
GeoDataLineString * dateLineCorrected = isClosed ? new GeoDataLinearRing( f )
: new GeoDataLineString( f );
qreal currentLon = 0.0;
qreal previousLon = 0.0;
int previousSign = 1;
bool unfinished = false;
for (; itPoint != itEndPoint; ++itPoint ) {
currentLon = itPoint->longitude();
int currentSign = ( currentLon < 0.0 ) ? -1 : +1 ;
if( itPoint == q.constBegin() ) {
previousSign = currentSign;
previousLon = currentLon;
}
// If we are crossing the date line ...
if ( previousSign != currentSign && fabs(previousLon) + fabs(currentLon) > M_PI ) {
unfinished = !unfinished;
GeoDataCoordinates previousTemp;
GeoDataCoordinates currentTemp;
interpolateDateLine( *itPreviousPoint, *itPoint,
previousTemp, currentTemp, q.tessellationFlags() );
*dateLineCorrected << previousTemp;
if ( isClosed && unfinished ) {
// If it's a linear ring and if it crossed the IDL only once then
// store the current string inside the unfinishedLineString for later use ...
unfinishedLineString = dateLineCorrected;
// ... and start a new linear ring for now.
dateLineCorrected = new GeoDataLinearRing( f );
}
else {
// Now it can only be a (finished) line string or a finished linear ring.
// Store it in the vector if the size is not zero.
if ( dateLineCorrected->size() > 0 ) {
lineStrings << dateLineCorrected;
}
else {
// Or delete it.
delete dateLineCorrected;
}
// If it's a finished linear ring restore the "remembered" unfinished String
if ( isClosed && !unfinished && unfinishedLineString ) {
dateLineCorrected = unfinishedLineString;
}
else {
// if it's a line string just create a new line string.
dateLineCorrected = new GeoDataLineString( f );
}
}
*dateLineCorrected << currentTemp;
*dateLineCorrected << *itPoint;
}
else {
*dateLineCorrected << *itPoint;
}
previousSign = currentSign;
previousLon = currentLon;
itPreviousPoint = itPoint;
}
// If the line string doesn't cross the dateline an even number of times
// then need to take care of the data stored in the unfinishedLineString
if ( unfinished && unfinishedLineString && !unfinishedLineString->isEmpty() ) {
*dateLineCorrected << *unfinishedLineString;
delete unfinishedLineString;
}
lineStrings << dateLineCorrected;
}
bool CylindricalProjectionPrivate::lineStringToPolygon( const GeoDataLineString &lineString,
const ViewportParams *viewport,
QVector<QPolygonF *> &polygons ) const
{
const TessellationFlags f = lineString.tessellationFlags();
qreal x = 0;
qreal y = 0;
qreal previousX = -1.0;
qreal previousY = -1.0;
int mirrorCount = 0;
qreal distance = repeatDistance( viewport );
polygons.append( new QPolygonF );
GeoDataLineString::ConstIterator itCoords = lineString.constBegin();
GeoDataLineString::ConstIterator itPreviousCoords = lineString.constBegin();
GeoDataLineString::ConstIterator itBegin = lineString.constBegin();
GeoDataLineString::ConstIterator itEnd = lineString.constEnd();
bool processingLastNode = false;
// We use a while loop to be able to cover linestrings as well as linear rings:
// Linear rings require to tessellate the path from the last node to the first node
// which isn't really convenient to achieve with a for loop ...
const bool isLong = lineString.size() > 10;
const int maximumDetail = levelForResolution(viewport->angularResolution());
// The first node of optimized linestrings has a non-zero detail value.
const bool hasDetail = itBegin->detail() != 0;
while ( itCoords != itEnd )
{
// Optimization for line strings with a big amount of nodes
bool skipNode = (hasDetail ? itCoords->detail() > maximumDetail
: itCoords != itBegin && isLong && !processingLastNode &&
!viewport->resolves( *itPreviousCoords, *itCoords ) );
if ( !skipNode ) {
Q_Q( const CylindricalProjection );
q->screenCoordinates( *itCoords, viewport, x, y );
// Initializing variables that store the values of the previous iteration
if ( !processingLastNode && itCoords == itBegin ) {
itPreviousCoords = itCoords;
previousX = x;
previousY = y;
}
// This if-clause contains the section that tessellates the line
// segments of a linestring. If you are about to learn how the code of
// this class works you can safely ignore this section for a start.
if ( lineString.tessellate() ) {
mirrorCount = tessellateLineSegment( *itPreviousCoords, previousX, previousY,
*itCoords, x, y,
polygons, viewport,
f, mirrorCount, distance );
}
else {
// special case for polys which cross dateline but have no Tesselation Flag
// the expected rendering is a screen coordinates straight line between
// points, but in projections with repeatX things are not smooth
mirrorCount = crossDateLine( *itPreviousCoords, *itCoords, x, y, polygons, mirrorCount, distance );
}
itPreviousCoords = itCoords;
previousX = x;
previousY = y;
}
// Here we modify the condition to be able to process the
// first node after the last node in a LinearRing.
if ( processingLastNode ) {
break;
}
++itCoords;
if ( itCoords == itEnd && lineString.isClosed() ) {
itCoords = itBegin;
processingLastNode = true;
}
}
GeoDataLatLonAltBox box = lineString.latLonAltBox();
// Closing e.g. in the Antarctica case.
// This code makes the assumption that
// - the first node is located at 180 E
// - and the last node is located at 180 W
// TODO: add a similar pattern in the crossDateLine() code.
/*
if( lineString.isClosed() && box.width() == 2*M_PI ) {
QPolygonF *poly = polygons.last();
if( box.containsPole( NorthPole ) ) {
qreal topMargin = 0.0;
qreal dummy = 0.0;
q_ptr->screenCoordinates(0.0, q_ptr->maxLat(), viewport, topMargin, dummy );
poly->push_back( QPointF( poly->last().x(), topMargin ) );
poly->push_back( QPointF( poly->first().x(), topMargin ) );
} else {
qreal bottomMargin = 0.0;
qreal dummy = 0.0;
q_ptr->screenCoordinates(0.0, q_ptr->minLat(), viewport, bottomMargin, dummy );
poly->push_back( QPointF( poly->last().x(), bottomMargin ) );
poly->push_back( QPointF( poly->first().x(), bottomMargin ) );
}
} */
repeatPolygons( viewport, polygons );
return polygons.isEmpty();
}
void GeoDataLineStringPrivate::toPoleCorrected( const GeoDataLineString& q, GeoDataLineString& poleCorrected )
{
poleCorrected.setTessellationFlags( q.tessellationFlags() );
GeoDataCoordinates previousCoords;
GeoDataCoordinates currentCoords;
if ( q.isClosed() ) {
if ( !( m_vector.first().isPole() ) &&
( m_vector.last().isPole() ) ) {
qreal firstLongitude = ( m_vector.first() ).longitude();
GeoDataCoordinates modifiedCoords( m_vector.last() );
modifiedCoords.setLongitude( firstLongitude );
poleCorrected << modifiedCoords;
}
}
QVector<GeoDataCoordinates>::const_iterator itCoords = m_vector.constBegin();
QVector<GeoDataCoordinates>::const_iterator itEnd = m_vector.constEnd();
for( ; itCoords != itEnd; ++itCoords ) {
currentCoords = *itCoords;
if ( itCoords == m_vector.constBegin() ) {
previousCoords = currentCoords;
}
if ( currentCoords.isPole() ) {
if ( previousCoords.isPole() ) {
continue;
}
else {
qreal previousLongitude = previousCoords.longitude();
GeoDataCoordinates currentModifiedCoords( currentCoords );
currentModifiedCoords.setLongitude( previousLongitude );
poleCorrected << currentModifiedCoords;
}
}
else {
if ( previousCoords.isPole() ) {
qreal currentLongitude = currentCoords.longitude();
GeoDataCoordinates previousModifiedCoords( previousCoords );
previousModifiedCoords.setLongitude( currentLongitude );
poleCorrected << previousModifiedCoords;
poleCorrected << currentCoords;
}
else {
// No poles at all. Nothing special to handle
poleCorrected << currentCoords;
}
}
previousCoords = currentCoords;
}
if ( q.isClosed() ) {
if ( ( m_vector.first().isPole() ) &&
!( m_vector.last().isPole() ) ) {
qreal lastLongitude = ( m_vector.last() ).longitude();
GeoDataCoordinates modifiedCoords( m_vector.first() );
modifiedCoords.setLongitude( lastLongitude );
poleCorrected << modifiedCoords;
}
}
}
int main(int argc, char** argv)
{
QApplication app(argc,argv);
qDebug( " Syntax: pnt2svg [-i shp-sourcefile -o pn2-targetfile]" );
QString inputFilename;
int inputIndex = app.arguments().indexOf( "-i" );
if ( inputIndex > 0 && inputIndex + 1 < argc )
inputFilename = app.arguments().at( inputIndex + 1 );
QString outputFilename = "output.pn2";
int outputIndex = app.arguments().indexOf("-o");
if ( outputIndex > 0 && outputIndex + 1 < argc )
outputFilename = app.arguments().at( outputIndex + 1 );
MarbleModel *model = new MarbleModel;
ParsingRunnerManager* manager = new ParsingRunnerManager( model->pluginManager() );
GeoDataDocument* document = manager->openFile( inputFilename );
QFile file( outputFilename );
file.open( QIODevice::WriteOnly );
QDataStream stream( &file );
quint8 fileHeaderVersion;
quint32 fileHeaderPolygons;
fileHeaderVersion = 1;
fileHeaderPolygons = 0; // This variable counts the number of polygons inside the document
QVector<GeoDataFeature*>::Iterator i = document->begin();
QVector<GeoDataFeature*>::Iterator const end = document->end();
for (; i != end; ++i) {
GeoDataPlacemark* placemark = static_cast<GeoDataPlacemark*>( *i );
// Types of placemarks
GeoDataPolygon* polygon = dynamic_cast<GeoDataPolygon*>( placemark->geometry() );
GeoDataLineString* linestring = dynamic_cast<GeoDataLineString*>( placemark->geometry() );
GeoDataMultiGeometry* multigeom = dynamic_cast<GeoDataMultiGeometry*>( placemark->geometry() );
if ( polygon ) {
fileHeaderPolygons += 1 + polygon->innerBoundaries().size(); // outer boundary + number of inner boundaries of the polygon
}
if ( linestring ) {
++fileHeaderPolygons;
}
if ( multigeom ) {
fileHeaderPolygons += multigeom->size(); // number of polygons inside the multigeometry
}
}
stream << fileHeaderVersion << fileHeaderPolygons;
i = document->begin();
quint32 polyCurrentID = 0;
quint32 polyParentNodes;
quint8 polyFlag;
for ( ; i != end; ++i ) {
GeoDataPlacemark* placemark = static_cast<GeoDataPlacemark*>( *i );
// Types of placemarks
GeoDataPolygon* polygon = dynamic_cast<GeoDataPolygon*>( placemark->geometry() );
GeoDataLineString* linestring = dynamic_cast<GeoDataLineString*>( placemark->geometry() );
GeoDataMultiGeometry* multigeom = dynamic_cast<GeoDataMultiGeometry*>( placemark->geometry() );
if ( polygon ) {
// Outer boundary
++polyCurrentID;
QVector<GeoDataCoordinates>::Iterator jBegin = polygon->outerBoundary().begin();
QVector<GeoDataCoordinates>::Iterator jEnd = polygon->outerBoundary().end();
polyParentNodes = getParentNodes( jBegin, jEnd );
polyFlag = OUTERBOUNDARY;
stream << polyCurrentID << polyParentNodes << polyFlag;
printAllNodes( jBegin, jEnd, stream );
// Inner boundaries
QVector<GeoDataLinearRing>::Iterator inner = polygon->innerBoundaries().begin();
QVector<GeoDataLinearRing>::Iterator innerEnd = polygon->innerBoundaries().end();
for ( ; inner != innerEnd; ++inner ) {
GeoDataLinearRing linearring = static_cast<GeoDataLinearRing>( *inner );
++polyCurrentID;
jBegin = linearring.begin();
jEnd = linearring.end();
polyParentNodes = getParentNodes( jBegin, jEnd );
polyFlag = INNERBOUNDARY;
stream << polyCurrentID << polyParentNodes << polyFlag;
printAllNodes( jBegin, jEnd, stream );
}
}
if ( linestring ) {
++polyCurrentID;
QVector<GeoDataCoordinates>::Iterator jBegin = linestring->begin();
QVector<GeoDataCoordinates>::Iterator jEnd = linestring->end();
polyParentNodes = getParentNodes( jBegin, jEnd );
if ( linestring->isClosed() )
polyFlag = LINEARRING;
else
polyFlag = LINESTRING;
stream << polyCurrentID << polyParentNodes << polyFlag;
printAllNodes( jBegin, jEnd, stream );
}
if ( multigeom ) {
QVector<GeoDataGeometry*>::Iterator multi = multigeom->begin();
QVector<GeoDataGeometry*>::Iterator multiEnd = multigeom->end();
for ( ; multi != multiEnd; ++multi ) {
GeoDataLineString* currLineString = dynamic_cast<GeoDataLineString*>( *multi );
++polyCurrentID;
QVector<GeoDataCoordinates>::Iterator jBegin = currLineString->begin();
QVector<GeoDataCoordinates>::Iterator jEnd = currLineString->end();
polyParentNodes = getParentNodes( jBegin, jEnd );
if ( currLineString->isClosed() )
polyFlag = LINEARRING;
else
polyFlag = LINESTRING;
stream << polyCurrentID << polyParentNodes << polyFlag;
printAllNodes( jBegin, jEnd, stream );
}
}
}
}