void QgsGeometryAreaCheck::collectErrors( QList<QgsGeometryCheckError*>& errors, QStringList &/*messages*/, QAtomicInt* progressCounter , const QgsFeatureIds &ids ) const
{
const QgsFeatureIds& featureIds = ids.isEmpty() ? mFeaturePool->getFeatureIds() : ids;
foreach ( const QgsFeatureId& featureid, featureIds )
{
if ( progressCounter ) progressCounter->fetchAndAddRelaxed( 1 );
QgsFeature feature;
if ( !mFeaturePool->get( featureid, feature ) )
{
continue;
}
QgsAbstractGeometryV2* geom = feature.geometry()->geometry();
if ( dynamic_cast<QgsGeometryCollectionV2*>( geom ) )
{
QgsGeometryCollectionV2* multiGeom = static_cast<QgsGeometryCollectionV2*>( geom );
for ( int i = 0, n = multiGeom->numGeometries(); i < n; ++i )
{
double value;
if ( checkThreshold( multiGeom->geometryN( i ), value ) )
{
errors.append( new QgsGeometryCheckError( this, featureid, multiGeom->geometryN( i )->centroid(), QgsVertexId( i ), value, QgsGeometryCheckError::ValueArea ) );
}
}
}
else
{
double value;
if ( checkThreshold( geom, value ) )
{
errors.append( new QgsGeometryCheckError( this, featureid, geom->centroid(), QgsVertexId( 0 ), value, QgsGeometryCheckError::ValueArea ) );
}
}
}
}
void SpikeDisplayNode::handleEvent(int eventType, MidiMessage& event, int samplePosition)
{
//std::cout << "Received event of type " << eventType << std::endl;
if (eventType == SPIKE)
{
const uint8_t* dataptr = event.getRawData();
int bufferSize = event.getRawDataSize();
if (bufferSize > 0)
{
SpikeObject newSpike;
bool isValid = unpackSpike(&newSpike, dataptr, bufferSize);
if (isValid)
{
int electrodeNum = newSpike.source;
Electrode& e = electrodes.getReference(electrodeNum);
// std::cout << electrodeNum << std::endl;
bool aboveThreshold = false;
// update threshold / check threshold
for (int i = 0; i < e.numChannels; i++)
{
e.detectorThresholds.set(i, float(newSpike.threshold[i])); // / float(newSpike.gain[i]));
aboveThreshold = aboveThreshold | checkThreshold(i, e.displayThresholds[i], newSpike);
}
if (aboveThreshold)
{
// add to buffer
if (e.currentSpikeIndex < displayBufferSize)
{
// std::cout << "Adding spike " << e.currentSpikeIndex + 1 << std::endl;
e.mostRecentSpikes.set(e.currentSpikeIndex, newSpike);
e.currentSpikeIndex++;
}
// save spike
if (isRecording)
{
getProcessorGraph()->getRecordNode()->writeSpike(newSpike,e.recordIndex);
}
}
}
}
}
}
void QgsGeometryAreaCheck::fixError( QgsGeometryCheckError *error, int method, const QMap<QString, int> &mergeAttributeIndices, Changes &changes ) const
{
QgsFeaturePool *featurePool = mContext->featurePools[ error->layerId() ];
QgsFeature feature;
if ( !featurePool->get( error->featureId(), feature ) )
{
error->setObsolete();
return;
}
double layerToMapUnits = featurePool->getLayerToMapUnits();
QgsGeometry g = feature.geometry();
const QgsAbstractGeometry *geom = g.constGet();
QgsVertexId vidx = error->vidx();
// Check if polygon still exists
if ( !vidx.isValid( geom ) )
{
error->setObsolete();
return;
}
// Check if error still applies
double value;
if ( !checkThreshold( layerToMapUnits, QgsGeometryCheckerUtils::getGeomPart( geom, vidx.part ), value ) )
{
error->setObsolete();
return;
}
// Fix with selected method
if ( method == NoChange )
{
error->setFixed( method );
}
else if ( method == Delete )
{
deleteFeatureGeometryPart( error->layerId(), feature, vidx.part, changes );
error->setFixed( method );
}
else if ( method == MergeLongestEdge || method == MergeLargestArea || method == MergeIdenticalAttribute )
{
QString errMsg;
if ( mergeWithNeighbor( error->layerId(), feature, vidx.part, method, mergeAttributeIndices[error->layerId()], changes, errMsg ) )
{
error->setFixed( method );
}
else
{
error->setFixFailed( tr( "Failed to merge with neighbor: %1" ).arg( errMsg ) );
}
}
else
{
error->setFixFailed( tr( "Unknown method" ) );
}
}
int main(void)
{
while(1){
char *uptime = parseUptime();
char *load = parseLoadtime();
char *CPU = parseTemp();
char *IP = parseIP();
checkThreshold(CPU);
char postit[POST_SIZE];
snprintf(postit, POST_SIZE, "Up: %s, Load: %s, CPU: %s, IP: %s", uptime, load, CPU, IP);
post(postit);
sleep(90);
}
return 0;
}
void QgsGeometryAreaCheck::collectErrors( QList<QgsGeometryCheckError *> &errors, QStringList &/*messages*/, QAtomicInt *progressCounter, const QMap<QString, QgsFeatureIds> &ids ) const
{
QMap<QString, QgsFeatureIds> featureIds = ids.isEmpty() ? allLayerFeatureIds() : ids;
QgsGeometryCheckerUtils::LayerFeatures layerFeatures( mContext->featurePools, featureIds, mCompatibleGeometryTypes, progressCounter );
for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeature : layerFeatures )
{
double layerToMapUnits = layerFeature.layerToMapUnits();
const QgsAbstractGeometry *geom = layerFeature.geometry();
for ( int iPart = 0, nParts = geom->partCount(); iPart < nParts; ++iPart )
{
double value;
const QgsAbstractGeometry *part = QgsGeometryCheckerUtils::getGeomPart( geom, iPart );
if ( checkThreshold( layerToMapUnits, part, value ) )
{
errors.append( new QgsGeometryCheckError( this, layerFeature, part->centroid(), QgsVertexId( iPart ), value * layerToMapUnits * layerToMapUnits, QgsGeometryCheckError::ValueArea ) );
}
}
}
}
bool LLLoperations::initializeLLL(const MutableMatrix *A,
gmp_QQ threshold,
MutableMatrix *& LLLstate)
{
// First check m: should be a matrix over globalZZ.
if (A == 0 || A->get_ring() != globalZZ)
{
ERROR("LLL only defined for matrices over ZZ");
return false;
}
ring_elem num = globalZZ->from_int(mpq_numref(threshold));
ring_elem den = globalZZ->from_int(mpq_denref(threshold));
// Check that 'threshold' is in range, and set the numerator, denom
if (!checkThreshold(num,den))
{
ERROR("LLL threshold should be in the range (1/4, 1]");
globalZZ->remove(num);
globalZZ->remove(den);
return false;
}
// LLLstate has n+4 columns, and n rows.
// First n columns: LLLstate(i,i) = D#i
// LLLstate(i,j) = lambda#(j,i) for
// Last four columns just have entries in row 0:
// The entries are: k, kmax, alphaTop, alphaBottom: all are ZZ values.
int n = A->n_cols();
LLLstate = MutableMatrix::zero_matrix(globalZZ,n,n+4,A->is_dense());
if (n > 0)
{
LLLstate->set_entry(0,n,globalZZ->from_int(1)); // k := 2
//LLLstate->set_entry(0,n+1,globalZZ->from_int(0)); // kmax := 1
LLLstate->set_entry(0,n+2,num); // Set threshold numerator, denominator
LLLstate->set_entry(0,n+3,den);
ring_elem dot;
A->dot_product(0,0,dot);
LLLstate->set_entry(0,0,dot); // D#1 := dot(A,0,0)
}
return true;
}
void QgsGeometryAreaCheck::fixError( QgsGeometryCheckError* error, int method, int mergeAttributeIndex, Changes &changes ) const
{
QgsFeature feature;
if ( !mFeaturePool->get( error->featureId(), feature ) )
{
error->setObsolete();
return;
}
QgsAbstractGeometryV2* geom = feature.geometry()->geometry();
const QgsVertexId& vidx = error->vidx();
// Check if polygon still exists
if ( !vidx.isValid( geom ) )
{
error->setObsolete();
return;
}
// Check if error still applies
if ( dynamic_cast<QgsGeometryCollectionV2*>( geom ) )
{
double value;
if ( !checkThreshold( static_cast<QgsGeometryCollectionV2*>( geom )->geometryN( vidx.part ), value ) )
{
error->setObsolete();
return;
}
}
else
{
double value;
if ( !checkThreshold( geom, value ) )
{
error->setObsolete();
return;
}
}
// Fix with selected method
if ( method == NoChange )
{
error->setFixed( method );
}
else if ( method == Delete )
{
deleteFeatureGeometryPart( feature, vidx.part, changes );
error->setFixed( method );
}
else if ( method == MergeLongestEdge || method == MergeLargestArea || method == MergeIdenticalAttribute )
{
QString errMsg;
if ( mergeWithNeighbor( feature, vidx.part, method, mergeAttributeIndex, changes, errMsg ) )
{
error->setFixed( method );
}
else
{
error->setFixFailed( tr( "Failed to merge with neighbor: %1" ).arg( errMsg ) );
}
}
else
{
error->setFixFailed( tr( "Unknown method" ) );
}
}
