QGIS » QGIS Application

    QgsDebugMsg( "Raster units per pixel  : " + QString::number( layer->rasterUnitsPerPixel() ) );

    QgsDebugMsg( "MapUnitsPerPixel before : " + QString::number( mMapCanvas->mapUnitsPerPixel() ) );

    mMapCanvas->refresh();

    QgsDebugMsg( "MapUnitsPerPixel after  : " + QString::number( mMapCanvas->mapUnitsPerPixel() ) );

#include "qgsdisplayangle.h"

#include <QSettings>

#include <cmath>

QgsDisplayAngle::QgsDisplayAngle( QWidget * parent, Qt::WindowFlags f ): QDialog( parent, f )

{

        }

        else

        {  // calculate perpendicular distance to line (pythagorean theorem):

        }

        if ( max_dist < dist_to_seg )

        {

#include "qgsvectordataprovider.h"

#include "qgstolerance.h"

#include "qgsgeometry.h"

#include <QMouseEvent>

#include <QMessageBox>

#include "qgslogger.h"

int QgsLabelDialog::itemNoForField( QString theFieldName, QStringList theFieldList )

{

  //if no matches assume first item in list is blank and return that

}

QgsLabelDialog::~QgsLabelDialog()

#include "qgsrubberband.h"

#include <QMouseEvent>

#include <QSettings>

#include <cmath>

QgsMapToolMeasureAngle::QgsMapToolMeasureAngle( QgsMapCanvas* canvas ): QgsMapTool( canvas ), mRubberBand( 0 ), mResultDisplay( 0 )

{

      double azimutOne = distArea->bearing( mAnglePoints.at( 1 ), mAnglePoints.at( 0 ) );

      double azimutTwo = distArea->bearing( mAnglePoints.at( 1 ), point );

      double resultAngle = azimutTwo - azimutOne;

      QgsDebugMsg( QString::number( M_PI ) );

      {

        if ( resultAngle < 0 )

        {

  for ( ; it != overlayPluginList.constEnd(); ++it )

  {

    QgsApplyDialog* d = ( *it )->dialog( lyr );

    tabWidget->setCurrentIndex( position ); //ugly, but otherwise the properties dialog is a mess

    mOverlayDialogs.push_back( d );

  }

  tblAttributes->setHorizontalHeaderItem( attrEditTypeCol, new QTableWidgetItem( tr( "Edit widget" ) ) );

  tblAttributes->setHorizontalHeaderItem( attrAliasCol, new QTableWidgetItem( tr( "Alias" ) ) );

  tblAttributes->setSelectionBehavior( QAbstractItemView::SelectRows );

  tblAttributes->setSelectionMode( QAbstractItemView::MultiSelection );

  QString xMin, yMin, xMax, yMax;

  double changeoverValue = 99999; // The 'largest' 5 digit number

  {

    xMin = QString( "%1" ).arg( myExtent.xMinimum(), 0, 'f', 2 );

  }

    xMin = QString( "%1" ).arg( myExtent.xMinimum() );

  }

  {

    yMin = QString( "%1" ).arg( myExtent.yMinimum(), 0, 'f', 2 );

  }

    yMin = QString( "%1" ).arg( myExtent.yMinimum() );

  }

  {

    xMax = QString( "%1" ).arg( myExtent.xMaximum(), 0, 'f', 2 );

  }

    xMax = QString( "%1" ).arg( myExtent.xMaximum() );

  }

  {

    yMax = QString( "%1" ).arg( myExtent.yMaximum(), 0, 'f', 2 );

  }

#include "qgspointrotationitem.h"

#include <QPainter>

#include <cmath>

QgsPointRotationItem::QgsPointRotationItem( QgsMapCanvas* canvas ): QgsMapCanvasItem( canvas ), mOrientation( Clockwise ), mRotation( 0.0 )

{

      double x1 = points[i].x();

      double x2 = points[i+1].x();

      {

        if ( x2 < x1 )

        {

  for ( int i = 0; i < nlines; i++ )

  {

    int type = mProvider->readLine( NULL, NULL, line );

    if ( type & GV_LINES )

  if ( lines == 0

       || _image == 0

       || !region.isValid()

       || this->_lines <= region.height() ) return;

  QRect scrollRect;

  void* firstCharPos = &_image[ region.top() * this->_columns ];

  int top = _topMargin + ( region.top() * _fontHeight );

  int bytesToMove = linesToMove *

                    this->_columns *

                    sizeof( Character );

    //set region of the display to scroll, making sure that

    //the region aligns correctly to the character grid

    scrollRect = QRect( topPoint ,

                        QSize( this->_usedColumns * _fontWidth ,

    double x = toReal( values[11], 0.0 );

    double y = toReal( values[21], 0.0 );

    {

      if ( y > 0.0 )

      {

          double dist = sqrt( pow( x2 - x1, 2 ) + pow( y2 - y1, 2 ) ) / 2.0;

          // alpha can't be 0.0 at this point

          double h = sqrt( wu );

          double angle = acos(( x2 - x1 ) / dist );

            angle -= M_PI / 2.0;

          }

          {

            h *= -1.0;

          }

  {

    dw.dxfReal( 10, data.x );

    dw.dxfReal( 20, data.y );

    {

      dw.dxfReal( 42, data.bulge );

    }

    //dw.entityAttributes(attrib);

    dw.dxfString( 8, polylineLayer );

    dw.coord( VERTEX_COORD_CODE, data.x, data.y );

    {

      dw.dxfReal( 42, data.bulge );

    }

#include "qgsvectorlayer.h"

#include <QDomElement>

#include <QPainter>

#include <cmath>

{

  mRenderer = QgsFeatureRendererV2::defaultRenderer( QGis::Point );

  mCenterSymbol = new QgsMarkerSymbolV2(); //the symbol for the center of a displacement group

  QgsSymbolV2RenderContext symbolContext( context, QgsSymbolV2::MM, 1.0, selected );

  double circleAdditionPainterUnits = symbolContext.outputLineWidth( mCircleRadiusAddition );

  //draw Circle

  drawCircle( radius, symbolContext, pt, symbolList.size() );

#include "qgsgeorefdatapoint.h"

#include <QPainter>

#include <cfloat>

#include <cmath>

QgsResidualPlotItem::QgsResidualPlotItem( QgsComposition* c ): QgsComposerItem( c ), mConvertScaleToMapUnits( false )

{

int CPL_STDCALL QgsImageWarper::updateWarpProgress( double dfComplete, const char *pszMessage, void *pProgressArg )

{

  QProgressDialog *progress = static_cast<QProgressDialog*>( pProgressArg );

  qApp->processEvents();

  // TODO: call QEventLoop manually to make "cancel" button more responsive

  if ( progress->wasCanceled() )

        case 3: src = QgsPoint( dX, oY + ( double )s*stepY ); break;

      }

      t.transform( src, raster, rasterToWorld );

    }

  }

  return QgsRectangle( minX, minY, maxX, maxY );

#include "qgsleastsquares.h"

#include <cmath>

using std::cos;

using std::sin;

using std::pow;

  else

  {

    // Guard against division by zero

    {

      for ( int i = 0; i < nPointCount; ++i )

      {

  return true;

}

{

  mGDALTransformer     = NULL;

  mGDALTransformerArgs = NULL;

  // GSL does not support a full SVD, so we artificially add a linear dependent row

  // to the matrix in case the system is underconstrained.

  uint n = 9;

  gsl_matrix *S = gsl_matrix_alloc( m, n );

#include "qgsrastermatrix.h"

#include <string.h>

#include <cmath>

QgsRasterMatrix::QgsRasterMatrix(): mColumns( 0 ), mRows( 0 ), mData( 0 )

{

}

QgsRasterMatrix::QgsRasterMatrix( int nCols, int nRows, float* data, double nodataValue ):

{

}

bool QgsRasterMatrix::oneArgumentOperation( OneArgOperator op )

{

  {

    return false;

  }

  int nEntries = mColumns * mRows;

  double value;

  {

    value = mData[i];

    {

      {

        case opSQRT:

          {

            mData[i] = static_cast<float>( mNodataValue );

          }

bool QgsRasterMatrix::twoArgumentOperation( TwoArgOperator op, const QgsRasterMatrix& other )

{

  {

    //operations with nodata values always generate nodata

    {

      mData[0] = static_cast<float>( mNodataValue );

      return true;

    }

    {

      case opPLUS:

        mData[0] = static_cast<float>( number() + other.number() );

        mData[0] = static_cast<float>( number() * other.number() );

        break;

      case opDIV:

        {

          mData[0] = static_cast<float>( mNodataValue );

        }

        }

        break;

      case opPOW:

        {

          mData[0] = static_cast<float>( mNodataValue );

        }

  }

  //two matrices

  {

    float* matrix = other.mData;

    int nEntries = mColumns * mRows;

    double value1, value2;

    {

      value1 = mData[i]; value2 = matrix[i];

      {

        mData[i] = static_cast<float>( mNodataValue );

      }

      else

      {

        {

          case opPLUS:

            mData[i] = static_cast<float>( value1 + value2 );

            mData[i] = static_cast<float>( value1 * value2 );

            break;

          case opDIV:

            {

              mData[i] = static_cast<float>( mNodataValue );

            }

            }

            break;

          case opPOW:

            {

              mData[i] = static_cast<float>( mNodataValue );

            }

  }

  //this matrix is a single number and the other one a real matrix

  {

    float* matrix = other.mData;

    int nEntries = other.nColumns() * other.nRows();

    mData = new float[nEntries]; mColumns = other.nColumns(); mRows = other.nRows();

    mNodataValue = other.nodataValue();

    {

      {

        mData[i] = static_cast<float>( mNodataValue );

      }

      return true;

    }

    {

      {

        mData[i] = static_cast<float>( mNodataValue );

        continue;

      }

      {

        case opPLUS:

          mData[i] = static_cast<float>( value + matrix[i] );

          mData[i] = static_cast<float>( value * matrix[i] );

          break;

        case opDIV:

          {

            mData[i] = static_cast<float>( mNodataValue );

          }

          }

          break;

        case opPOW:

          {

            mData[i] = static_cast<float>( mNodataValue );

          }

    double value = other.number();

    int nEntries = mColumns * mRows;

    {

      {

        mData[i] = static_cast<float>( mNodataValue );

      }

      return true;

    }

    {

      {

        continue;

      }

      {

        case opPLUS:

          mData[i] = static_cast<float>( mData[i] + value );

          mData[i] = static_cast<float>( mData[i] * value );

          break;

        case opDIV:

          {

            mData[i] = static_cast<float>( mNodataValue );

          }

          }

          break;

        case opPOW:

          {

            mData[i] = static_cast<float>( mNodataValue );

          }

bool QgsRasterMatrix::testPowerValidity( double base, double power )

{

  {

    return false;

  }

        //Take the higher z-Value in case of two equal points

        Point3D* newPoint = mPointVector[mPointVector.count()-1];

        Point3D* existingPoint = mPointVector[mTwiceInsPoint];

        mPointVector.remove( mPointVector.count() - 1 );

        delete newPoint;

#ifndef MATHUTILS_H

#define MATHUTILS_H

#include <cmath>

#include "Vector3D.h"

#include "Point3D.h"

#ifndef POINT3D_H

#define POINT3D_H

#include <cmath>

#include <iostream>

/**Point3D is a class to represent a three dimensional point*/

#ifndef VECTOR3D_H

#define VECTOR3D_H

#include <cmath>

class ANALYSIS_EXPORT Vector3D

      /**

    double a = normal.getX();

    double b = normal.getY();

    double c = -( normal.getX() * p2->getX() + normal.getY() * p2->getY() );

    return distance;

  }

  else

    return 1;

  }

  double tmp = a;

  {

    a *= tmp;

#include "CloughTocherInterpolator.h"

#include "qgslogger.h"

#include <cmath>

double CloughTocherInterpolator::calcBernsteinPoly( int n, int i, int j, int k, double u, double v, double w )

{

    // Don't want to interfer with mouse events

    QgsRectangle currentExtent = mMapRenderer->extent();

    switch ( e->key() )

    {

  QgsPoint start = getCoordinateTransform()->toMapCoordinates( mCanvasProperties->rubberStartPoint );

  QgsPoint end = getCoordinateTransform()->toMapCoordinates( releasePoint );

  // modify the extent

  QgsRectangle r = mMapRenderer->extent();

    halfSymbolSize = scaledSymbolSize() / 2.0;

  }

  mBoundingRect = QRectF( xMinPos, yMinPos, xMaxPos - xMinPos, yMaxPos - yMinPos );

}

  int cursorSensitivity = 7;

  {

    return MoveMapPosition;

  }

  bool left, right, up, down;

  if ( left && up )

  {

QString QgsPoint::toDegreesMinutesSeconds( int thePrecision ) const

{

  float myFloatMinutesX = float(( qAbs( m_x ) - myDegreesX ) * 60 );

  int myIntMinutesX = int( myFloatMinutesX );

  float mySecondsX = float( myFloatMinutesX - myIntMinutesX ) * 60;

  float myFloatMinutesY = float(( qAbs( m_y ) - myDegreesY ) * 60 );

  int myIntMinutesY = int( myFloatMinutesY );

  float mySecondsY = float( myFloatMinutesY - myIntMinutesY ) * 60;

{

  //algorithm from 'graphics GEMS', A. Paeth: 'A Fast 2D Point-on-line test'

  if (

  )

  {

    return 0;

      for ( int i = 0; i < pa.size(); ++i )

      {

      }

      QgsDebugMsg( QString( "Largest  X coordinate was %1" ).arg( largestX ) );

      QgsDebugMsg( QString( "Smallest X coordinate was %1" ).arg( smallestX ) );

 ***************************************************************************/

/* $Id$ */

#include "qgslogger.h"

#include "qgsrectangle.h"

#include "qgsscalecalculator.h"

      delta = calculateGeographicDistance( mapExtent );

      break;

    default:

      break;

  }

  QgsDebugMsg( "Using conversionFactor of " + QString::number( conversionFactor ) );

#include "qgscolorrampshader.h"

QgsColorRampShader::QgsColorRampShader( double theMinimumValue, double theMaximumValue ) : QgsRasterShaderFunction( theMinimumValue, theMaximumValue )

{

  {

    //Start searching from the last index - assumtion is that neighboring pixels tend to be similar values

    myColorRampItem = mColorRampItemList.value( mCurrentColorRampItemIndex );

    //If the previous entry is less, then search closer to the top of the list (assumes mColorRampItemList is sorted)

    if ( mCurrentColorRampItemIndex != 0 && theValue <= mColorRampItemList.at( mCurrentColorRampItemIndex - 1 ).value )

    {

  {

    //Start searching from the last index - assumtion is that neighboring pixels tend to be similar values

    myColorRampItem = mColorRampItemList.value( mCurrentColorRampItemIndex );

    if ( theValue == myColorRampItem.value || myTinyDiff <= DOUBLE_DIFF_THRESHOLD )

    {

      *theReturnRedValue = myColorRampItem.color.red();

  {

    //Start searching from the last index - assumtion is that neighboring pixels tend to be similar values

    myColorRampItem = mColorRampItemList.value( mCurrentColorRampItemIndex );

    //If the previous entry is less, then search closer to the top of the list (assumes mColorRampItemList is sorted)

    if ( mCurrentColorRampItemIndex != 0 && theValue <= mColorRampItemList.at( mCurrentColorRampItemIndex - 1 ).value )

    {

        {

          double myValue = readValue( myData, myDataType, iX + ( iY * myXBlockSize ) );

          {

            continue; // NULL

          }

        {

          double myValue = readValue( myData, myDataType, iX + ( iY * myXBlockSize ) );

          {

            continue; // NULL

          }

      for ( int myColumn = 0; myColumn < mLastViewPort.drawableAreaXDim; ++myColumn )

      {

        myValue = readValue( myGdalScanData, myDataType, myRow * mLastViewPort.drawableAreaXDim + myColumn );

        {

          continue;

        }

  // calculate raster pixel offsets from origin to clipped rect

  // we're only interested in positive offsets where the origin of the raster

  // is northwest of the origin of the view

  if ( myRasterViewPort->rectXOffsetFloat < 0 )

  {

  myRasterViewPort->topLeftPoint = theQgsMapToPixel.transform( myRasterExtent.xMinimum(), myRasterExtent.yMaximum() );

  myRasterViewPort->bottomRightPoint = theQgsMapToPixel.transform( myRasterExtent.xMaximum(), myRasterExtent.yMinimum() );

  //the drawable area can start to get very very large when you get down displaying 2x2 or smaller, this is becasue

  //theQgsMapToPixel.mapUnitsPerPixel() is less then 1,

    //fetch image in several parts if it is too memory consuming

    //also some WMS servers have a pixel limit, so it's better to make several requests

                               / theQgsMapToPixel.mapUnitsPerPixel() * mGeoTransform[1] ) + 1;

                                / theQgsMapToPixel.mapUnitsPerPixel() * mGeoTransform[5] ) + 1;

    int numParts = totalPixelWidth * totalPixelHeight / 5000000 + 1.0;

    int numRowsPerPart = totalPixelHeight / numParts + 1.0;

#endif

      QString v;

      {

        v = tr( "null (no data)" );

      }

// We can only use one of the mGeoTransform[], so go with the

// horisontal one.

}

/**

      if ( mValidNoDataValue &&

           (

           )

         )

      {

      myBlueValue = 0;

      myPixelValue = readValue( rasterScanLine, ( GDALDataType )myDataType, i );

      {

        imageScanLine[ i ] = myDefaultColor;

        continue;

      myBlueValue = 0;

      myPixelValue = readValue( rasterScanLine, ( GDALDataType )myDataType, i );

      {

        imageScanLine[ i ] = myDefaultColor;

        continue;

      myBlueValue = 0;

      myPixelValue = readValue( rasterScanLine, ( GDALDataType )myDataType, i );

      {

        imageScanLine[ i ] = myDefaultColor;

        continue;

    {

      myGrayValue = readValue( rasterScanLine, ( GDALDataType )myDataType, i );

      {

        imageScanLine[ i ] = myDefaultColor;

        continue;

    {

      myPixelValue = readValue( rasterScanLine, myDataType, i );

      {

        imageScanLine[ i ] = myDefaultColor;

        continue;

                     ( theRasterViewPort->rectXOffsetFloat -

                       theRasterViewPort->rectXOffset )

                     / theQgsMapToPixel->mapUnitsPerPixel()

                   );

    paintYoffset = static_cast<int>(

                     ( theRasterViewPort->rectYOffsetFloat -

                       theRasterViewPort->rectYOffset )

                     / theQgsMapToPixel->mapUnitsPerPixel()

                   );

  }

    int myPixelBoundaryY = 0;

    if ( theQgsMapToPixel )

    {

    }

    //INSTANCE: 1x2

                           ( mViewPort->rectXOffsetFloat -

                             mViewPort->rectXOffset )

                           / mMapToPixel->mapUnitsPerPixel()

                         );

          paintYoffset = static_cast<int>(

                           ( mViewPort->rectYOffsetFloat -

                             mViewPort->rectYOffset )

                           / mMapToPixel->mapUnitsPerPixel()

                         );

          imageX = static_cast<int>( mViewPort->topLeftPoint.x() + 0.5 );

        }

        mPainter->drawImage( imageX,

  int overlapRows = 0;

  if ( mMapToPixel )

  {

  }

  if ( mCurrentPartRasterMax + overlapRows >= mViewPort->clippedHeight )

  {

  {

    if ( mMapToPixel )

    {

    }

  }

  if ( ySize < 1 || xSize < 1 )

                     ( mViewPort->rectXOffsetFloat -

                       mViewPort->rectXOffset )

                     / mMapToPixel->mapUnitsPerPixel()

                   );

    paintYoffset = static_cast<int>(

                     ( mViewPort->rectYOffsetFloat -

                       mViewPort->rectYOffset )

                     / mMapToPixel->mapUnitsPerPixel()

                   );

  }

    int myPixelBoundaryY = 0;

    if ( mMapToPixel )

    {

    }

    //INSTANCE: 1x2

    int precision = 0;

    if (( width() < 1 || height() < 1 ) && ( width() > 0 && height() > 0 ) )

    {

      // sanity check

      if ( precision > 20 )

        precision = 20;

#include "qgssymbol.h"

#include "qgssymbologyutils.h"

#include "qgslogger.h"

#include <QDomNode>

#include <QPainter>

#include <QImage>

    {

      //first find out the value for the scale classification attribute

      const QgsAttributeMap& attrs = f.attributeMap();

    }

    if ( symbol->rotationClassificationField() >= 0 )

    {

#include "qgsvectordataprovider.h"

#include "qgsvectorlayer.h"

#include "qgsrendercontext.h"

#include <QDomNode>

#include <QDomElement>

#include <QImage>

    {

      //first find out the value for the scale classification attribute

      const QgsAttributeMap& attrs = f.attributeMap();

      QgsDebugMsgLevel( QString( "Feature has field scale factor %1" ).arg( fieldScale ), 3 );

    }

    if ( theSymbol->rotationClassificationField() >= 0 )

#include <QImage>

#include <QPainter>

#include <QString>

QgsSingleSymbolRenderer::QgsSingleSymbolRenderer( QGis::GeometryType type )

{

    {

      //first find out the value for the scale classification attribute

      const QgsAttributeMap& attrs = f.attributeMap();

      QgsDebugMsgLevel( QString( "Feature has field scale factor %1" ).arg( fieldScale ), 3 );

    }

    if ( mSymbol0->rotationClassificationField() >= 0 )

  }

  QgsPoint ptSize = xform->toMapCoordinates( w, h );

}

  if ( distance != 0 )

  {

  }

  //add parameters for data defined labeling to QgsPalGeometry

  double tu2 = 0;

  int iterLimit = 20;

  {

    sinLambda = sin( lambda );

    cosLambda = cos( lambda );

  }

  // QgsDebugMsg("Area from point: " + (points[i % size]).toString(2));

  area = area / 2.0;

}

QString QgsDistanceArea::textUnit( double value, int decimals, QGis::UnitType u, bool isArea, bool keepBaseUnit )

        {

          unitLabel = QObject::tr( " m2" );

        }

        {

          unitLabel = QObject::tr( " km2" );

          value = value / 1000000.0;

        }

        {

          unitLabel = QObject::tr( " ha" );

          value = value / 10000.0;

      }

      else

      {

        {

          unitLabel = QObject::tr( " m" );

        }

        {

          unitLabel = QObject::tr( " km" );

          value = value / 1000;

        }

        {

          unitLabel = QObject::tr( " mm" );

          value = value * 1000;

        }

        {

          unitLabel = QObject::tr( " cm" );

          value = value * 100;

    case QGis::Feet:

      if ( isArea )

      {

        {

          unitLabel = QObject::tr( " sq ft" );

        }

      }

      else

      {

        {

          {

            unitLabel = QObject::tr( " foot" );

          }

      }

      else

      {

          unitLabel = QObject::tr( " degree" );

        else

          unitLabel = QObject::tr( " degrees" );

#include <QSettings>

#include <iostream>

#include <cmath>

#define EVAL_STR(x) (x.length() ? x : "(empty)")

QgsSearchTreeNode::QgsSearchTreeNode( QgsSearchTreeNode::Type t )

  {

    // Use abs() on the extent to avoid the case where the extent is

    // symmetrical about 0.

    double xRange = extent.width() / xMean;

    double yRange = extent.height() / yMean;

      QgsMapToPixel rasterMapToPixel;

      QgsMapToPixel bk_mapToPixel;

      {

        scaleRaster = true;

      }

        rl * blockSize

      )

      {

        byte* tmp;

        try

    );

  // maximum resident set size

  // total memory

}

void Tools::ResourceUsage::stop()

  m_writeIO += ru.ru_oublock - m_tmpRU.ru_oublock;

  // maximum resident set size

  // total memory

  // page faults

  m_pageFaults += ru.ru_majflt - m_tmpRU.ru_majflt;

        // if there are no more records in the file, do nothing.

      }

      cRun++;

      if ( cRun == runs.size() ) cRun = 0;

    }

      for ( unsigned long cChild = 0; cChild < e.m_pNode->m_children; cChild++ )

      {

      }

    }

      for ( unsigned long cChild = 0; cChild < m_children; cChild++ )

      {

      }

    }

  }