String AbnfGenContext::generate () const
{
String r;
// Before normalization
size_t origRulesCount = m_rulelist.elements().size();
if (! m_rulelist.normalize()) {
Logger::error(_Tr("Failed to normalize ABNF rulelist"));
return String();
}
String ttcText(generateTransitionTablesClass(m_rulelist, transitionType(), sourceDataType()));
String ttText(generateTransitionTables(m_rulelist, m_options, origRulesCount));
if (ttcText.isEmpty() || ttText.isEmpty())
return String();
String headerText(generateHeader(sourceDataType()));
String enumText(generateEnum(m_rulelist, origRulesCount));
String actionFlags(generateActionArgs(m_rulelist, origRulesCount));
String actionsText(generateActions(m_rulelist, origRulesCount, sourceDataType()));
r << headerText << String::EndOfLine
<< enumText << String::EndOfLine
<< ttcText << String::EndOfLine
<< actionFlags << String::EndOfLine
<< ttText << String::EndOfLine
<< actionsText;
return r;
}
Qgis::DataType QgsGrassRasterProvider::dataType( int bandNo ) const
{
return sourceDataType( bandNo );
}
void QgsRasterInterface::cumulativeCut( int bandNo,
double lowerCount, double upperCount,
double &lowerValue, double &upperValue,
const QgsRectangle &extent,
int sampleSize )
{
QgsDebugMsgLevel( QString( "theBandNo = %1 lowerCount = %2 upperCount = %3 sampleSize = %4" ).arg( bandNo ).arg( lowerCount ).arg( upperCount ).arg( sampleSize ), 4 );
int mySrcDataType = sourceDataType( bandNo );
// Init to NaN is better than histogram min/max to catch errors
lowerValue = std::numeric_limits<double>::quiet_NaN();
upperValue = std::numeric_limits<double>::quiet_NaN();
//get band stats to specify real histogram min/max (fix #9793 Byte bands)
QgsRasterBandStats stats = bandStatistics( bandNo, QgsRasterBandStats::Min, extent, sampleSize );
if ( stats.maximumValue < stats.minimumValue )
return;
// for byte bands make sure bin count == actual range
int myBinCount = ( mySrcDataType == Qgis::Byte ) ? int( std::ceil( stats.maximumValue - stats.minimumValue + 1 ) ) : 0;
QgsRasterHistogram myHistogram = histogram( bandNo, myBinCount, stats.minimumValue, stats.maximumValue, extent, sampleSize );
//QgsRasterHistogram myHistogram = histogram( bandNo, 0, std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN(), extent, sampleSize );
double myBinXStep = ( myHistogram.maximum - myHistogram.minimum ) / myHistogram.binCount;
int myCount = 0;
int myMinCount = static_cast< int >( std::round( lowerCount * myHistogram.nonNullCount ) );
int myMaxCount = static_cast< int >( std::round( upperCount * myHistogram.nonNullCount ) );
bool myLowerFound = false;
QgsDebugMsgLevel( QString( "binCount = %1 minimum = %2 maximum = %3 myBinXStep = %4" ).arg( myHistogram.binCount ).arg( myHistogram.minimum ).arg( myHistogram.maximum ).arg( myBinXStep ), 4 );
QgsDebugMsgLevel( QString( "myMinCount = %1 myMaxCount = %2" ).arg( myMinCount ).arg( myMaxCount ), 4 );
for ( int myBin = 0; myBin < myHistogram.histogramVector.size(); myBin++ )
{
int myBinValue = myHistogram.histogramVector.value( myBin );
myCount += myBinValue;
if ( !myLowerFound && myCount > myMinCount )
{
lowerValue = myHistogram.minimum + myBin * myBinXStep;
myLowerFound = true;
QgsDebugMsgLevel( QString( "found lowerValue %1 at bin %2" ).arg( lowerValue ).arg( myBin ), 4 );
}
if ( myCount >= myMaxCount )
{
upperValue = myHistogram.minimum + myBin * myBinXStep;
QgsDebugMsgLevel( QString( "found upperValue %1 at bin %2" ).arg( upperValue ).arg( myBin ), 4 );
break;
}
}
// fix integer data - round down/up
if ( mySrcDataType == Qgis::Byte ||
mySrcDataType == Qgis::Int16 || mySrcDataType == Qgis::Int32 ||
mySrcDataType == Qgis::UInt16 || mySrcDataType == Qgis::UInt32 )
{
if ( lowerValue != std::numeric_limits<double>::quiet_NaN() )
lowerValue = std::floor( lowerValue );
if ( upperValue != std::numeric_limits<double>::quiet_NaN() )
upperValue = std::ceil( upperValue );
}
}
///////////////////////////////////////////////////////////
//
// Returns a data handler for the waveform
//
///////////////////////////////////////////////////////////
ptr<handlers::dataHandler> waveform::getIntegerData(std::uint32_t channel, std::int32_t paddingValue)
{
PUNTOEXE_FUNCTION_START(L"waveform::getIntegerData");
static std::int32_t uLawDecompressTable[256] =
{
-32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
-23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
-15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
-11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
-7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
-5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
-3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
-2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
-1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
-1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
-876, -844, -812, -780, -748, -716, -684, -652,
-620, -588, -556, -524, -492, -460, -428, -396,
-372, -356, -340, -324, -308, -292, -276, -260,
-244, -228, -212, -196, -180, -164, -148, -132,
-120, -112, -104, -96, -88, -80, -72, -64,
-56, -48, -40, -32, -24, -16, -8, 0,
32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
876, 844, 812, 780, 748, 716, 684, 652,
620, 588, 556, 524, 492, 460, 428, 396,
372, 356, 340, 324, 308, 292, 276, 260,
244, 228, 212, 196, 180, 164, 148, 132,
120, 112, 104, 96, 88, 80, 72, 64,
56, 48, 40, 32, 24, 16, 8, 0
};
static std::int32_t aLawDecompressTable[256] =
{
-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
-3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
-22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
-30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
-11008,-10496,-12032,-11520,-8960, -8448, -9984, -9472,
-15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
-344, -328, -376, -360, -280, -264, -312, -296,
-472, -456, -504, -488, -408, -392, -440, -424,
-88, -72, -120, -104, -24, -8, -56, -40,
-216, -200, -248, -232, -152, -136, -184, -168,
-1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
-1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
-688, -656, -752, -720, -560, -528, -624, -592,
-944, -912, -1008, -976, -816, -784, -880, -848,
5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
344, 328, 376, 360, 280, 264, 312, 296,
472, 456, 504, 488, 408, 392, 440, 424,
88, 72, 120, 104, 24, 8, 56, 40,
216, 200, 248, 232, 152, 136, 184, 168,
1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
688, 656, 752, 720, 560, 528, 624, 592,
944, 912, 1008, 976, 816, 784, 880, 848
};
// Lock the dataset during the interpretation of the
// dataset
///////////////////////////////////////////////////////////
lockObject lockDataSet(m_pDataSet);
// Get the original data
///////////////////////////////////////////////////////////
ptr<handlers::dataHandler> waveformData(m_pDataSet->getDataHandler(0x5400, 0x0, 0x1010, 0, false));
std::string sourceDataType(waveformData->getDataType());
// Get the interpretation, number of channels, number of
// samples
///////////////////////////////////////////////////////////
std::string waveformInterpretation(getInterpretation());
std::uint32_t numChannels(getChannels());
std::uint32_t numSamples(getSamples());
std::uint32_t originalPaddingValue(0);
bool bPaddingValueExists(false);
ptr<handlers::dataHandler> paddingTagHandler(m_pDataSet->getDataHandler(0x5400, 0, 0x100A, 0, false));
if(paddingTagHandler != 0)
{
originalPaddingValue = paddingTagHandler->getUnsignedLong(0);
bPaddingValueExists = true;
}
// Allocate a buffer for the destination data
///////////////////////////////////////////////////////////
ptr<buffer> waveformBuffer(new buffer(0, "SL"));
ptr<handlers::dataHandler> destinationHandler(waveformBuffer->getDataHandler(true, numSamples));
// Copy the data to the destination for unsigned values
///////////////////////////////////////////////////////////
std::uint32_t waveformPointer(channel);
std::uint32_t destinationPointer(0);
if(sourceDataType == "UB" || sourceDataType == "US")
{
for(std::uint32_t copySamples (numSamples); copySamples != 0; --copySamples)
{
std::uint32_t unsignedData(waveformData->getUnsignedLong(waveformPointer));
waveformPointer += numChannels;
if(bPaddingValueExists && unsignedData == originalPaddingValue)
{
destinationHandler->setSignedLong(destinationPointer++, paddingValue);
continue;
}
destinationHandler->setUnsignedLong(destinationPointer++, unsignedData);
}
return destinationHandler;
}
// Copy the data to the destination for signed values
///////////////////////////////////////////////////////////
int highBit(getBitsAllocated() - 1);
std::uint32_t testBit = ((std::uint32_t)1) << highBit;
std::uint32_t orBits = ((std::uint32_t)((std::int32_t)-1)) << highBit;
for(std::uint32_t copySamples (numSamples); copySamples != 0; --copySamples)
{
std::uint32_t unsignedData = waveformData->getUnsignedLong(waveformPointer);
waveformPointer += numChannels;
if(bPaddingValueExists && unsignedData == originalPaddingValue)
{
destinationHandler->setSignedLong(destinationPointer++, paddingValue);;
continue;
}
if((unsignedData & testBit) != 0)
{
unsignedData |= orBits;
}
destinationHandler->setSignedLong(destinationPointer++, (std::int32_t)unsignedData);
}
// Now decompress uLaw or aLaw
if(waveformInterpretation == "AB") // 8bits aLaw
{
for(std::uint32_t aLawSamples(0); aLawSamples != numSamples; ++aLawSamples)
{
std::uint32_t compressed(destinationHandler->getUnsignedLong(aLawSamples));
if(bPaddingValueExists && compressed == originalPaddingValue)
{
continue;
}
std::int32_t decompressed(aLawDecompressTable[compressed]);
destinationHandler->setSignedLong(aLawSamples, decompressed);
}
}
// Now decompress uLaw or aLaw
if(waveformInterpretation == "MB") // 8bits aLaw
{
for(std::uint32_t uLawSamples(0); uLawSamples != numSamples; ++uLawSamples)
{
std::uint32_t compressed(destinationHandler->getUnsignedLong(uLawSamples));
if(bPaddingValueExists && compressed == originalPaddingValue)
{
continue;
}
std::int32_t decompressed(uLawDecompressTable[compressed]);
destinationHandler->setSignedLong(uLawSamples, decompressed);
}
}
return destinationHandler;
PUNTOEXE_FUNCTION_END();
}
void QgsRasterInterface::initHistogram( QgsRasterHistogram &histogram,
int bandNo,
int binCount,
double minimum, double maximum,
const QgsRectangle &boundingBox,
int sampleSize,
bool includeOutOfRange )
{
histogram.bandNumber = bandNo;
histogram.minimum = minimum;
histogram.maximum = maximum;
histogram.includeOutOfRange = includeOutOfRange;
int mySrcDataType = sourceDataType( bandNo );
if ( std::isnan( histogram.minimum ) )
{
// TODO: this was OK when stats/histogram were calced in provider,
// but what TODO in other interfaces? Check for mInput for now.
if ( !mInput && mySrcDataType == Qgis::Byte )
{
histogram.minimum = 0; // see histogram() for shift for rounding
}
else
{
// We need statistics -> avoid histogramDefaults in hasHistogram if possible
// TODO: use approximated statistics if approximated histogram is requested
// (theSampleSize > 0)
QgsRasterBandStats stats = bandStatistics( bandNo, QgsRasterBandStats::Min, boundingBox, sampleSize );
histogram.minimum = stats.minimumValue;
}
}
if ( std::isnan( histogram.maximum ) )
{
if ( !mInput && mySrcDataType == Qgis::Byte )
{
histogram.maximum = 255;
}
else
{
QgsRasterBandStats stats = bandStatistics( bandNo, QgsRasterBandStats::Max, boundingBox, sampleSize );
histogram.maximum = stats.maximumValue;
}
}
QgsRectangle finalExtent;
if ( boundingBox.isEmpty() )
{
finalExtent = extent();
}
else
{
finalExtent = extent().intersect( boundingBox );
}
histogram.extent = finalExtent;
if ( sampleSize > 0 )
{
// Calc resolution from theSampleSize
double xRes, yRes;
xRes = yRes = std::sqrt( ( finalExtent.width() * finalExtent.height() ) / sampleSize );
// But limit by physical resolution
if ( capabilities() & Size )
{
double srcXRes = extent().width() / xSize();
double srcYRes = extent().height() / ySize();
if ( xRes < srcXRes ) xRes = srcXRes;
if ( yRes < srcYRes ) yRes = srcYRes;
}
QgsDebugMsgLevel( QString( "xRes = %1 yRes = %2" ).arg( xRes ).arg( yRes ), 4 );
histogram.width = static_cast <int>( finalExtent.width() / xRes );
histogram.height = static_cast <int>( finalExtent.height() / yRes );
}
else
{
if ( capabilities() & Size )
{
histogram.width = xSize();
histogram.height = ySize();
}
else
{
histogram.width = 1000;
histogram.height = 1000;
}
}
QgsDebugMsgLevel( QString( "theHistogram.width = %1 histogram.height = %2" ).arg( histogram.width ).arg( histogram.height ), 4 );
int myBinCount = binCount;
if ( myBinCount == 0 )
{
// TODO: this was OK when stats/histogram were calced in provider,
// but what TODO in other interfaces? Check for mInput for now.
if ( !mInput && mySrcDataType == Qgis::Byte )
{
myBinCount = 256; // Cannot store more values in byte
}
else
{
// There is no best default value, to display something reasonable in histogram chart, binCount should be small, OTOH, to get precise data for cumulative cut, the number should be big. Because it is easier to define fixed lower value for the chart, we calc optimum binCount for higher resolution (to avoid calculating that where histogram() is used. In any any case, it does not make sense to use more than width*height;
myBinCount = histogram.width * histogram.height;
if ( myBinCount > 1000 ) myBinCount = 1000;
// for Int16/Int32 make sure bin count <= actual range, because there is no sense in having
// bins at fractional values
if ( !mInput && (
mySrcDataType == Qgis::Int16 || mySrcDataType == Qgis::Int32 ||
mySrcDataType == Qgis::UInt16 || mySrcDataType == Qgis::UInt32 ) )
{
if ( myBinCount > histogram.maximum - histogram.minimum + 1 )
myBinCount = int( std::ceil( histogram.maximum - histogram.minimum + 1 ) );
}
}
}
histogram.binCount = myBinCount;
QgsDebugMsgLevel( QString( "theHistogram.binCount = %1" ).arg( histogram.binCount ), 4 );
}
