QString QgsLineStringV2::asWkt( int precision ) const
{
QString wkt = wktTypeStr() + " ";
QList<QgsPointV2> pts;
points( pts );
wkt += QgsGeometryUtils::pointsToWKT( pts, precision, is3D(), isMeasure() );
return wkt;
}
QString QgsCircularStringV2::asWkt( int precision ) const
{
QString wkt = wktTypeStr() + ' ';
QgsPointSequenceV2 pts;
points( pts );
wkt += QgsGeometryUtils::pointsToWKT( pts, precision, is3D(), isMeasure() );
return wkt;
}
bool QgsTriangle::fromWkt( const QString &wkt )
{
clear();
QPair<QgsWkbTypes::Type, QString> parts = QgsGeometryUtils::wktReadBlock( wkt );
if ( QgsWkbTypes::geometryType( parts.first ) != QgsWkbTypes::PolygonGeometry )
return false;
mWkbType = parts.first;
QString defaultChildWkbType = QStringLiteral( "LineString%1%2" ).arg( is3D() ? QStringLiteral( "Z" ) : QString(), isMeasure() ? QStringLiteral( "M" ) : QString() );
const QStringList blocks = QgsGeometryUtils::wktGetChildBlocks( parts.second, defaultChildWkbType );
for ( const QString &childWkt : blocks )
{
QPair<QgsWkbTypes::Type, QString> childParts = QgsGeometryUtils::wktReadBlock( childWkt );
QgsWkbTypes::Type flatCurveType = QgsWkbTypes::flatType( childParts.first );
if ( flatCurveType == QgsWkbTypes::LineString )
mInteriorRings.append( new QgsLineString() );
else
{
clear();
return false;
}
if ( !mInteriorRings.back()->fromWkt( childWkt ) )
{
clear();
return false;
}
}
if ( mInteriorRings.isEmpty() )
{
clear();
return false;
}
mExteriorRing.reset( mInteriorRings.takeFirst() );
//scan through rings and check if dimensionality of rings is different to CurvePolygon.
//if so, update the type dimensionality of the CurvePolygon to match
bool hasZ = false;
bool hasM = false;
if ( mExteriorRing )
{
hasZ = hasZ || mExteriorRing->is3D();
hasM = hasM || mExteriorRing->isMeasure();
}
if ( hasZ )
addZValue( 0 );
if ( hasM )
addMValue( 0 );
return true;
}
QString QgsAbstractGeometryV2::wktTypeStr() const
{
QString wkt = geometryType();
if ( is3D() )
wkt += 'Z';
if ( isMeasure() )
wkt += 'M';
return wkt;
}
bool QgsLineStringV2::dropZValue()
{
if ( !is3D() )
return false;
mWkbType = QgsWKBTypes::dropZ( mWkbType );
mZ.clear();
return true;
}
void HTMLCanvasElement::createImageBufferInternal()
{
ASSERT(!m_imageBuffer);
ASSERT(!m_contextStateSaver);
m_didFailToCreateImageBuffer = true;
m_didClearImageBuffer = true;
IntSize deviceSize = size();
if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
return;
if (deviceSize.width() > MaxSkiaDim || deviceSize.height() > MaxSkiaDim)
return;
if (!deviceSize.width() || !deviceSize.height())
return;
int msaaSampleCount;
OwnPtr<ImageBufferSurface> surface = createImageBufferSurface(deviceSize, &msaaSampleCount);
if (!surface->isValid())
return;
m_imageBuffer = ImageBuffer::create(surface.release());
m_imageBuffer->setClient(this);
m_didFailToCreateImageBuffer = false;
updateExternallyAllocatedMemory();
if (is3D()) {
// Early out for WebGL canvases
return;
}
m_imageBuffer->setClient(this);
m_imageBuffer->context()->setShouldClampToSourceRect(false);
m_imageBuffer->context()->disableAntialiasingOptimizationForHairlineImages();
m_imageBuffer->context()->setImageInterpolationQuality(CanvasDefaultInterpolationQuality);
// Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
// rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
// canvases but not in unaccelerated canvases.
if (!msaaSampleCount && document().settings() && !document().settings()->antialiased2dCanvasEnabled())
m_imageBuffer->context()->setShouldAntialias(false);
// GraphicsContext's defaults don't always agree with the 2d canvas spec.
// See CanvasRenderingContext2D::State::State() for more information.
m_imageBuffer->context()->setMiterLimit(10);
m_imageBuffer->context()->setStrokeThickness(1);
#if ENABLE(ASSERT)
m_imageBuffer->context()->disableDestructionChecks(); // 2D canvas is allowed to leave context in an unfinalized state.
#endif
m_contextStateSaver = adoptPtr(new GraphicsContextStateSaver(*m_imageBuffer->context()));
if (m_context)
setNeedsCompositingUpdate();
}
QString QgsLineStringV2::asKML( int precision ) const
{
QString kml;
if ( isRing() )
{
kml.append( "<LinearRing>" );
}
else
{
kml.append( "<LineString>" );
}
bool z = is3D();
kml.append( "<altitudeMode>" );
if ( z )
{
kml.append( "absolute" );
}
else
{
kml.append( "clampToGround" );
}
kml.append( "</altitudeMode>" );
kml.append( "<coordinates>" );
int nPoints = mCoords.size();
for ( int i = 0; i < nPoints; ++i )
{
if ( i > 0 )
{
kml.append( " " );
}
kml.append( qgsDoubleToString( mCoords[i].x(), precision ) );
kml.append( "," );
kml.append( qgsDoubleToString( mCoords[i].y(), precision ) );
if ( z )
{
kml.append( "," );
kml.append( qgsDoubleToString( mZ[i], precision ) );
}
else
{
kml.append( ",0" );
}
}
kml.append( "</coordinates>" );
if ( isRing() )
{
kml.append( "</LinearRing>" );
}
else
{
kml.append( "</LineString>" );
}
return kml;
}
bool Coordinate::operator == ( const Coordinate & other ) const
{
if ( isEmpty() ){
return other.isEmpty() ;
}
if ( is3D() || other.is3D() ){
return x() == other.x() && y() == other.y() && z() == other.z() ;
}else{
return x() == other.x() && y() == other.y() ;
}
}
unsigned char* QgsLineStringV2::asWkb( int& binarySize ) const
{
binarySize = wkbSize();
unsigned char* geomPtr = new unsigned char[binarySize];
QgsWkbPtr wkb( geomPtr );
wkb << static_cast<char>( QgsApplication::endian() );
wkb << static_cast<quint32>( wkbType() );
QList<QgsPointV2> pts;
points( pts );
QgsGeometryUtils::pointsToWKB( wkb, pts, is3D(), isMeasure() );
return geomPtr;
}
void HTMLCanvasElement::didProcessTask()
{
// This method gets invoked if didDraw was called earlier in the current task.
ASSERT(!m_dirtyRect.isEmpty());
if (is3D()) {
didFinalizeFrame();
} else {
ASSERT(hasImageBuffer());
m_imageBuffer->finalizeFrame(m_dirtyRect);
}
ASSERT(m_dirtyRect.isEmpty());
}
void HTMLCanvasElement::didChangeVisibilityState(PageVisibilityState visibility)
{
if (!m_context)
return;
bool hidden = visibility != PageVisibilityStateVisible;
m_context->setIsHidden(hidden);
if (hidden) {
clearCopiedImage();
if (is3D()) {
discardImageBuffer();
}
}
}
bool SFXEmitter::isInRange() const
{
if( !is3D() )
return true;
SFXListener& listener = SFX->getListener();
const Point3F listenerPos = listener.getTransform().getPosition();
const Point3F emitterPos = getPosition();
const F32 dist = getSFXDescription().mMaxDistance;
return ( ( emitterPos - listenerPos ).len() <= dist );
}
bool QgsLineStringV2::fromWkt( const QString& wkt )
{
clear();
QPair<QgsWKBTypes::Type, QString> parts = QgsGeometryUtils::wktReadBlock( wkt );
if ( QgsWKBTypes::flatType( parts.first ) != QgsWKBTypes::parseType( geometryType() ) )
return false;
mWkbType = parts.first;
setPoints( QgsGeometryUtils::pointsFromWKT( parts.second, is3D(), isMeasure() ) );
return true;
}
bool QgsMultiLineString::addGeometry( QgsAbstractGeometry *g )
{
if ( !dynamic_cast<QgsLineString *>( g ) )
{
delete g;
return false;
}
if ( mGeometries.empty() )
{
setZMTypeFromSubGeometry( g, QgsWkbTypes::MultiLineString );
}
if ( is3D() && !g->is3D() )
g->addZValue();
else if ( !is3D() && g->is3D() )
g->dropZValue();
if ( isMeasure() && !g->isMeasure() )
g->addMValue();
else if ( !isMeasure() && g->isMeasure() )
g->dropMValue();
return QgsGeometryCollection::addGeometry( g ); // clazy:exclude=skipped-base-method
}
bool QgsGeometryCollection::dropZValue()
{
if ( mWkbType != QgsWkbTypes::GeometryCollection && !is3D() )
return false;
mWkbType = QgsWkbTypes::dropZ( mWkbType );
for ( QgsAbstractGeometry *geom : qgis::as_const( mGeometries ) )
{
geom->dropZValue();
}
clearCache();
return true;
}
bool QgsCompoundCurve::fromWkt( const QString &wkt )
{
clear();
QPair<QgsWkbTypes::Type, QString> parts = QgsGeometryUtils::wktReadBlock( wkt );
if ( QgsWkbTypes::flatType( parts.first ) != QgsWkbTypes::CompoundCurve )
return false;
mWkbType = parts.first;
QString defaultChildWkbType = QStringLiteral( "LineString%1%2" ).arg( is3D() ? QStringLiteral( "Z" ) : QString(), isMeasure() ? QStringLiteral( "M" ) : QString() );
const QStringList blocks = QgsGeometryUtils::wktGetChildBlocks( parts.second, defaultChildWkbType );
for ( const QString &childWkt : blocks )
{
QPair<QgsWkbTypes::Type, QString> childParts = QgsGeometryUtils::wktReadBlock( childWkt );
if ( QgsWkbTypes::flatType( childParts.first ) == QgsWkbTypes::LineString )
mCurves.append( new QgsLineString() );
else if ( QgsWkbTypes::flatType( childParts.first ) == QgsWkbTypes::CircularString )
mCurves.append( new QgsCircularString() );
else
{
clear();
return false;
}
if ( !mCurves.back()->fromWkt( childWkt ) )
{
clear();
return false;
}
}
//scan through curves and check if dimensionality of curves is different to compound curve.
//if so, update the type dimensionality of the compound curve to match
bool hasZ = false;
bool hasM = false;
for ( const QgsCurve *curve : qgis::as_const( mCurves ) )
{
hasZ = hasZ || curve->is3D();
hasM = hasM || curve->isMeasure();
if ( hasZ && hasM )
break;
}
if ( hasZ )
addZValue( 0 );
if ( hasM )
addMValue( 0 );
return true;
}
bool Coordinate::operator < ( const Coordinate & other ) const
{
// no empty comparison
if ( isEmpty() || other.isEmpty() ){
BOOST_THROW_EXCEPTION( Exception("try to compare empty points using a < b ") );
}
// no mixed dimension comparison
if ( ( is3D() && ! other.is3D() ) || ( ! is3D() && other.is3D() ) ){
BOOST_THROW_EXCEPTION( Exception("try to compare empty points with different coordinate dimension using a < b") );
}
// comparison along x
if ( x() < other.x() ){
return true ;
}else if ( other.x() < x() ){
return false;
}
// comparison along y
if ( y() < other.y() ){
return true ;
}else if ( other.y() < y() ){
return false;
}
// comparison along z if possible
if ( is3D() ){
if ( z() < other.z() ){
return true ;
}else if ( other.z() < z() ){
return false;
}
}
// points are equals
return false;
}
bool QgsMultiSurface::addGeometry( QgsAbstractGeometry *g )
{
if ( !qgsgeometry_cast<QgsSurface *>( g ) )
{
delete g;
return false;
}
if ( mGeometries.empty() )
{
setZMTypeFromSubGeometry( g, QgsWkbTypes::MultiSurface );
}
if ( is3D() && !g->is3D() )
g->addZValue();
else if ( !is3D() && g->is3D() )
g->dropZValue();
if ( isMeasure() && !g->isMeasure() )
g->addMValue();
else if ( !isMeasure() && g->isMeasure() )
g->dropMValue();
return QgsGeometryCollection::addGeometry( g );
}
void QgsCircularString::deleteVertex( int i )
{
mX.remove( i );
mY.remove( i );
if ( is3D() )
{
mZ.remove( i );
}
if ( isMeasure() )
{
mM.remove( i );
}
clearCache();
}
QgsCircularString *QgsCircularString::reversed() const
{
QgsCircularString *copy = clone();
std::reverse( copy->mX.begin(), copy->mX.end() );
std::reverse( copy->mY.begin(), copy->mY.end() );
if ( is3D() )
{
std::reverse( copy->mZ.begin(), copy->mZ.end() );
}
if ( isMeasure() )
{
std::reverse( copy->mM.begin(), copy->mM.end() );
}
return copy;
}
void ArenaLocker::_loadSounds(std::string fileName, SoundManager* Sound)
{
auto sndList = soundList(fileName.c_str());
sSound sound;
for(auto itr = sndList->sound().begin(); itr != sndList->sound().end(); ++itr)
{
sound.is3D = itr->is3D();
sound.isLooping = itr->looping();
sound.name = itr->name();
Sound->createSound(sound,itr->filename().c_str());
_sounds.push_back(sound);
}
return;
}
bool QgsCurvePolygon::dropZValue()
{
if ( !is3D() )
return false;
mWkbType = QgsWkbTypes::dropZ( mWkbType );
if ( mExteriorRing )
mExteriorRing->dropZValue();
for ( QgsCurve *curve : qgis::as_const( mInteriorRings ) )
{
curve->dropZValue();
}
clearCache();
return true;
}
bool QgsCurve::isClosed() const
{
if ( numPoints() == 0 )
return false;
//don't consider M-coordinates when testing closedness
QgsPoint start = startPoint();
QgsPoint end = endPoint();
bool closed = qgsDoubleNear( start.x(), end.x(), 1E-8 ) &&
qgsDoubleNear( start.y(), end.y(), 1E-8 );
if ( is3D() && closed )
closed &= qgsDoubleNear( start.z(), end.z(), 1E-8 ) || ( std::isnan( start.z() ) && std::isnan( end.z() ) );
return closed;
}
QgsPointV2 QgsCircularString::pointN( int i ) const
{
if ( qMin( mX.size(), mY.size() ) <= i )
{
return QgsPointV2();
}
double x = mX.at( i );
double y = mY.at( i );
double z = 0;
double m = 0;
if ( is3D() )
{
z = mZ.at( i );
}
if ( isMeasure() )
{
m = mM.at( i );
}
QgsWkbTypes::Type t = QgsWkbTypes::Point;
if ( is3D() && isMeasure() )
{
t = QgsWkbTypes::PointZM;
}
else if ( is3D() )
{
t = QgsWkbTypes::PointZ;
}
else if ( isMeasure() )
{
t = QgsWkbTypes::PointM;
}
return QgsPointV2( t, x, y, z, m );
}
void QgsLineStringV2::addVertex( const QgsPointV2& pt )
{
if ( mWkbType == QgsWKBTypes::Unknown )
{
setZMTypeFromSubGeometry( &pt, QgsWKBTypes::LineString );
}
mCoords.append( QPointF( pt.x(), pt.y() ) );
if ( is3D() )
{
mZ.append( pt.z() );
}
if ( isMeasure() )
{
mM.append( pt.m() );
}
}
bool QgsLineStringV2::insertVertex( const QgsVertexId& position, const QgsPointV2& vertex )
{
if ( position.vertex < 0 || position.vertex > mCoords.size() )
{
return false;
}
mCoords.insert( position.vertex, QPointF( vertex.x(), vertex.y() ) );
if ( is3D() )
{
mZ.insert( position.vertex, vertex.z() );
}
if ( isMeasure() )
{
mM.insert( position.vertex, vertex.m() );
}
return true;
}
void QgsLineString::filterVertices( const std::function<bool ( const QgsPoint & )> &filter )
{
bool hasZ = is3D();
bool hasM = isMeasure();
int size = mX.size();
double *srcX = mX.data();
double *srcY = mY.data();
double *srcM = hasM ? mM.data() : nullptr;
double *srcZ = hasZ ? mZ.data() : nullptr;
double *destX = srcX;
double *destY = srcY;
double *destM = srcM;
double *destZ = srcZ;
int filteredPoints = 0;
for ( int i = 0; i < size; ++i )
{
double x = *srcX++;
double y = *srcY++;
double z = hasZ ? *srcZ++ : std::numeric_limits<double>::quiet_NaN();
double m = hasM ? *srcM++ : std::numeric_limits<double>::quiet_NaN();
if ( filter( QgsPoint( x, y, z, m ) ) )
{
filteredPoints++;
*destX++ = x;
*destY++ = y;
if ( hasM )
*destM++ = m;
if ( hasZ )
*destZ++ = z;
}
}
mX.resize( filteredPoints );
mY.resize( filteredPoints );
if ( hasZ )
mZ.resize( filteredPoints );
if ( hasM )
mM.resize( filteredPoints );
clearCache();
}
PassOwnPtr<ImageBufferSurface> HTMLCanvasElement::createImageBufferSurface(const IntSize& deviceSize, int* msaaSampleCount)
{
OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
*msaaSampleCount = 0;
if (is3D())
return adoptPtr(new WebGLImageBufferSurface(size(), opacityMode));
if (shouldAccelerate(deviceSize)) {
if (document().settings())
*msaaSampleCount = document().settings()->accelerated2dCanvasMSAASampleCount();
OwnPtr<ImageBufferSurface> surface = adoptPtr(new Canvas2DImageBufferSurface(size(), opacityMode, *msaaSampleCount));
if (surface->isValid())
return surface.release();
}
return adoptPtr(new UnacceleratedImageBufferSurface(size(), opacityMode));
}
// setFrame() - set the 2D frame i to the incoming signal.
void MLSignal::setFrame(int i, const MLSignal& src)
{
// only valid for 3D signals
assert(is3D());
// source must be 2D
assert(src.is2D());
// src signal should match our dimensions
if((src.getWidth() != mWidth) || (src.getHeight() != mHeight))
{
return;
}
MLSample* pDestFrame = mDataAligned + plane(i);
const MLSample* pSrc = src.getConstBuffer();
std::copy(pSrc, pSrc + src.getSize(), pDestFrame);
}
bool QgsLineStringV2::deleteVertex( const QgsVertexId& position )
{
if ( position.vertex >= mCoords.size() || position.vertex < 0 )
{
return false;
}
mCoords.remove( position.vertex );
if ( is3D() )
{
mZ.remove( position.vertex );
}
if ( isMeasure() )
{
mM.remove( position.vertex );
}
return true;
}
