void Window::run(const QString& cmd) {
KURIFilterData filterData(cmd);
KURIFilter::self()->filterURI(filterData);
kdDebug() << "filterData.uriType" << filterData.uriType() << endl;
switch (filterData.uriType()) {
case KURIFilterData::LOCAL_FILE:
case KURIFilterData::LOCAL_DIR:
case KURIFilterData::NET_PROTOCOL:
case KURIFilterData::HELP:
new KRun(filterData.uri(), this);
break;
case KURIFilterData::EXECUTABLE:
case KURIFilterData::SHELL:
KRun::runCommand(cmd);
break;
case KURIFilterData::BLOCKED:
case KURIFilterData::UNKNOWN:
case KURIFilterData::ERROR:
showErrorMessage("Could not start this command");
return;
}
hide();
}
void Analysis::filterCurrent()
{
if (filedata->hasCurrentVectors())
{
filterData(filedata->currentPivData(), settings->filterOptions());
emit(currentFiltered());
}
}
void DebugViewer::sendLogSlot(QByteArray text)
{
QStringList filterData(QString(text).split("\r\n"));
for(int n=0;n<filterData.count();n++)
if(filterData.at(n).startsWith("Cookie",Qt::CaseInsensitive))
filterData[n]="Cookie: THERE_WAS_A_COOKIE";
if(savingFile==false&&ui.checkEnabled->isChecked())
ui.debugText->appendPlainText(filterData.join("\n"));
}
void WebshortcutRunner::match(Plasma::RunnerContext &context)
{
const QString term = context.query();
if (term.length() < 3 || !term.contains(m_delimiter))
return;
// qDebug() << "checking term" << term;
const int delimIndex = term.indexOf(m_delimiter);
if (delimIndex == term.length() - 1)
return;
const QString key = term.left(delimIndex);
if (key == m_lastFailedKey) {
return; // we already know it's going to suck ;)
}
if (!context.isValid()) {
qDebug() << "invalid context";
return;
}
// Do a fake user feedback text update if the keyword has not changed.
// There is no point filtering the request on every key stroke.
// filtering
if (m_lastKey == key) {
m_filterBeforeRun = true;
m_match.setText(i18n("Search %1 for %2", m_lastProvider, term.mid(delimIndex + 1)));
context.addMatch(m_match);
return;
}
KUriFilterData filterData(term);
if (!KUriFilter::self()->filterSearchUri(filterData, KUriFilter::WebShortcutFilter)) {
m_lastFailedKey = key;
return;
}
m_lastFailedKey.clear();
m_lastKey = key;
m_lastProvider = filterData.searchProvider();
m_match.setData(filterData.uri().url());
m_match.setId("WebShortcut:" + key);
m_match.setIcon(QIcon::fromTheme(filterData.iconName()));
m_match.setText(i18n("Search %1 for %2", m_lastProvider, filterData.searchTerm()));
context.addMatch(m_match);
}
unsigned char* InputStream::getData()
{
bool isData = filterData();
if (!isData)
{
QMessageBox messageBox;
messageBox.critical(0,"Error","There is an error occured with depth sensor. Please, try to run this program again");
messageBox.setFixedSize(500,200);
return NULL;
}
else
return filtered_data;
}
bool Px3World::castRay( const Point3F &startPnt, const Point3F &endPnt, RayInfo *ri, const Point3F &impulse )
{
physx::PxVec3 orig = px3Cast<physx::PxVec3>( startPnt );
physx::PxVec3 dir = px3Cast<physx::PxVec3>( endPnt - startPnt );
physx::PxF32 maxDist = dir.magnitude();
dir.normalize();
U32 groups = 0xffffffff;
groups &= ~( PX3_TRIGGER ); // No trigger shapes!
physx::PxHitFlags outFlags(physx::PxHitFlag::eDISTANCE | physx::PxHitFlag::eIMPACT | physx::PxHitFlag::eNORMAL);
physx::PxQueryFilterData filterData(physx::PxQueryFlag::eSTATIC|physx::PxQueryFlag::eDYNAMIC);
filterData.data.word0 = groups;
physx::PxRaycastBuffer buf;
if(!mScene->raycast(orig,dir,maxDist,buf,outFlags,filterData))
return false;
if(!buf.hasBlock)
return false;
const physx::PxRaycastHit hit = buf.block;
physx::PxRigidActor *actor = hit.actor;
PhysicsUserData *userData = PhysicsUserData::cast( actor->userData );
if ( ri )
{
ri->object = ( userData != NULL ) ? userData->getObject() : NULL;
if ( ri->object == NULL )
ri->distance = hit.distance;
ri->normal = px3Cast<Point3F>( hit.normal );
ri->point = px3Cast<Point3F>( hit.position );
ri->t = maxDist / hit.distance;
}
if ( impulse.isZero() ||
!actor->isRigidDynamic() ||
actor->is<physx::PxRigidDynamic>()->getRigidDynamicFlags() & physx::PxRigidDynamicFlag::eKINEMATIC )
return true;
physx::PxRigidBody *body = actor->is<physx::PxRigidBody>();
physx::PxVec3 force = px3Cast<physx::PxVec3>( impulse );
physx::PxRigidBodyExt::addForceAtPos(*body,force,hit.position,physx::PxForceMode::eIMPULSE);
return true;
}
bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
{
ASSERT(object);
ASSERT(context);
ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
clearInvalidationMask();
if (m_filter.contains(object)) {
FilterData* filterData = m_filter.get(object);
if (filterData->state == FilterData::PaintingSource)
filterData->state = FilterData::CycleDetected;
return false; // Already built, or we're in a cycle. Regardless, just do nothing more now.
}
OwnPtr<FilterData> filterData(adoptPtr(new FilterData));
FloatRect targetBoundingBox = object->objectBoundingBox();
SVGFilterElement* filterElement = toSVGFilterElement(element());
filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(filterElement, filterElement->filterUnits()->currentValue()->enumValue(), targetBoundingBox);
if (filterData->boundaries.isEmpty())
return false;
filterData->drawingRegion = object->strokeBoundingBox();
filterData->drawingRegion.intersect(filterData->boundaries);
IntRect intDrawingRegion = enclosingIntRect(filterData->drawingRegion);
// Create the SVGFilter object.
bool primitiveBoundingBoxMode = filterElement->primitiveUnits()->currentValue()->enumValue() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
filterData->filter = SVGFilter::create(intDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);
// Create all relevant filter primitives.
filterData->builder = buildPrimitives(filterData->filter.get());
if (!filterData->builder)
return false;
FilterEffect* lastEffect = filterData->builder->lastEffect();
if (!lastEffect)
return false;
lastEffect->determineFilterPrimitiveSubregion(ClipToFilterRegion);
FilterData* data = filterData.get();
m_filter.set(object, filterData.release());
beginDeferredFilter(context, data);
return true;
}
void ZeoParser::process_waveform(char * buffer) {
if (printData) {
printf("We have waveform data: ");
}
for (int i = 0; i < RAW_DATA_LEN; i++) {
//int raw = *((short*) (buffer + 2*i)); // may be necessary for xcode
int raw = *((_int16*) (buffer + 2*i));
//value = float(value*315)/0x8000 # convert to uV value FIX
rawData.at(i) = ((float) raw * 315) / ((float) 0x8000);
if (printData) {
if (i<6) printf("%i, %f;", raw, rawData.at(i));
}
};
if (printData) {
printf("... Yay!\n");
}
filterData();
}
void BrushStroker::moveTo(const TabletInputData &originalData)
{
auto data = originalData;
filterData(data);
clearLastEditedKeys();
_count = 0;
_dataEnd = data;
if (_smoothed)
{
_dataPrev = data;
_dataStart = data;
}
else
{
drawFirst(data);
}
}
void BrushStroker::lineTo(const TabletInputData &originalData)
{
auto data = originalData;
filterData(data);
_count += 1;
if (_smoothed)
{
if (_count >= 2)
{
auto polygon = CurveSubdivision(Curve4::fromBSpline(_dataPrev.pos, _dataStart.pos, _dataEnd.pos, data.pos)).polygon();
if (_count == 2)
{
auto firstData = _dataStart;
firstData.pos = polygon.first();
drawFirst(firstData);
}
drawInterval(polygon, _dataStart, _dataEnd);
}
_dataPrev = _dataStart;
_dataStart = _dataEnd;
_dataEnd = data;
}
else
{
_dataStart = _dataEnd;
_dataEnd = data;
if (_dataStart.pos == _dataEnd.pos)
return;
_segment[0] = _dataStart.pos;
_segment[1] = _dataEnd.pos;
drawInterval(_segment, _dataStart, _dataEnd);
}
}
bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
{
ASSERT(object);
ASSERT(context);
#ifndef NDEBUG
ASSERT(resourceMode == ApplyToDefaultMode);
#else
UNUSED_PARAM(resourceMode);
#endif
// Returning false here, to avoid drawings onto the context. We just want to
// draw the stored filter output, not the unfiltered object as well.
if (m_filter.contains(object)) {
FilterData* filterData = m_filter.get(object);
if (filterData->builded)
return false;
delete m_filter.take(object); // Oops, have to rebuild, go through normal code path
}
OwnPtr<FilterData> filterData(new FilterData);
filterData->builder = buildPrimitives();
if (!filterData->builder)
return false;
FloatRect paintRect = object->strokeBoundingBox();
// Calculate the scale factor for the use of filterRes.
// Also see http://www.w3.org/TR/SVG/filters.html#FilterEffectsRegion
SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
filterData->boundaries = filterElement->filterBoundingBox(object->objectBoundingBox());
if (filterData->boundaries.isEmpty())
return false;
FloatSize scale(1.0f, 1.0f);
if (filterElement->hasAttribute(SVGNames::filterResAttr)) {
scale.setWidth(filterElement->filterResX() / filterData->boundaries.width());
scale.setHeight(filterElement->filterResY() / filterData->boundaries.height());
}
if (scale.isEmpty())
return false;
// clip sourceImage to filterRegion
FloatRect clippedSourceRect = paintRect;
clippedSourceRect.intersect(filterData->boundaries);
// scale filter size to filterRes
FloatRect tempSourceRect = clippedSourceRect;
// scale to big sourceImage size to kMaxFilterSize
tempSourceRect.scale(scale.width(), scale.height());
fitsInMaximumImageSize(tempSourceRect.size(), scale);
// prepare Filters
bool primitiveBoundingBoxMode = filterElement->primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
filterData->filter = SVGFilter::create(paintRect, filterData->boundaries, primitiveBoundingBoxMode);
filterData->filter->setFilterResolution(scale);
FilterEffect* lastEffect = filterData->builder->lastEffect();
if (!lastEffect)
return false;
lastEffect->calculateEffectRect(filterData->filter.get());
// At least one FilterEffect has a too big image size,
// recalculate the effect sizes with new scale factors.
if (!fitsInMaximumImageSize(filterData->filter->maxImageSize(), scale)) {
filterData->filter->setFilterResolution(scale);
lastEffect->calculateEffectRect(filterData->filter.get());
}
clippedSourceRect.scale(scale.width(), scale.height());
// Draw the content of the current element and it's childs to a imageBuffer to get the SourceGraphic.
// The size of the SourceGraphic is clipped to the size of the filterRegion.
IntRect bufferRect = enclosingIntRect(clippedSourceRect);
OwnPtr<ImageBuffer> sourceGraphic(ImageBuffer::create(bufferRect.size(), LinearRGB));
if (!sourceGraphic.get())
return false;
GraphicsContext* sourceGraphicContext = sourceGraphic->context();
sourceGraphicContext->translate(-clippedSourceRect.x(), -clippedSourceRect.y());
sourceGraphicContext->scale(scale);
sourceGraphicContext->clearRect(FloatRect(FloatPoint(), paintRect.size()));
filterData->sourceGraphicBuffer = sourceGraphic.release();
filterData->savedContext = context;
context = sourceGraphicContext;
ASSERT(!m_filter.contains(object));
m_filter.set(object, filterData.leakPtr());
return true;
}
bool RenderSVGResourceFilter::applyResource(RenderObject* object, RenderStyle*, GraphicsContext*& context, unsigned short resourceMode)
{
ASSERT(object);
ASSERT(context);
ASSERT_UNUSED(resourceMode, resourceMode == ApplyToDefaultMode);
// Returning false here, to avoid drawings onto the context. We just want to
// draw the stored filter output, not the unfiltered object as well.
if (m_filter.contains(object)) {
FilterData* filterData = m_filter.get(object);
if (filterData->builded)
return false;
delete m_filter.take(object); // Oops, have to rebuild, go through normal code path
}
OwnPtr<FilterData> filterData(adoptPtr(new FilterData));
FloatRect targetBoundingBox = object->objectBoundingBox();
SVGFilterElement* filterElement = static_cast<SVGFilterElement*>(node());
filterData->boundaries = SVGLengthContext::resolveRectangle<SVGFilterElement>(filterElement, filterElement->filterUnits(), targetBoundingBox);
if (filterData->boundaries.isEmpty())
return false;
// Determine absolute transformation matrix for filter.
AffineTransform absoluteTransform;
SVGImageBufferTools::calculateTransformationToOutermostSVGCoordinateSystem(object, absoluteTransform);
if (!absoluteTransform.isInvertible())
return false;
// Eliminate shear of the absolute transformation matrix, to be able to produce unsheared tile images for feTile.
filterData->shearFreeAbsoluteTransform = AffineTransform(absoluteTransform.xScale(), 0, 0, absoluteTransform.yScale(), 0, 0);
// Determine absolute boundaries of the filter and the drawing region.
FloatRect absoluteFilterBoundaries = filterData->shearFreeAbsoluteTransform.mapRect(filterData->boundaries);
FloatRect drawingRegion = object->strokeBoundingBox();
drawingRegion.intersect(filterData->boundaries);
FloatRect absoluteDrawingRegion = filterData->shearFreeAbsoluteTransform.mapRect(drawingRegion);
// Create the SVGFilter object.
bool primitiveBoundingBoxMode = filterElement->primitiveUnits() == SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX;
filterData->filter = SVGFilter::create(filterData->shearFreeAbsoluteTransform, absoluteDrawingRegion, targetBoundingBox, filterData->boundaries, primitiveBoundingBoxMode);
// Create all relevant filter primitives.
filterData->builder = buildPrimitives(filterData->filter.get());
if (!filterData->builder)
return false;
// Calculate the scale factor for the use of filterRes.
// Also see http://www.w3.org/TR/SVG/filters.html#FilterEffectsRegion
FloatSize scale(1, 1);
if (filterElement->hasAttribute(SVGNames::filterResAttr)) {
scale.setWidth(filterElement->filterResX() / absoluteFilterBoundaries.width());
scale.setHeight(filterElement->filterResY() / absoluteFilterBoundaries.height());
}
if (scale.isEmpty())
return false;
// Determine scale factor for filter. The size of intermediate ImageBuffers shouldn't be bigger than kMaxFilterSize.
FloatRect tempSourceRect = absoluteDrawingRegion;
tempSourceRect.scale(scale.width(), scale.height());
fitsInMaximumImageSize(tempSourceRect.size(), scale);
// Set the scale level in SVGFilter.
filterData->filter->setFilterResolution(scale);
FilterEffect* lastEffect = filterData->builder->lastEffect();
if (!lastEffect)
return false;
RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(lastEffect);
FloatRect subRegion = lastEffect->maxEffectRect();
// At least one FilterEffect has a too big image size,
// recalculate the effect sizes with new scale factors.
if (!fitsInMaximumImageSize(subRegion.size(), scale)) {
filterData->filter->setFilterResolution(scale);
RenderSVGResourceFilterPrimitive::determineFilterPrimitiveSubregion(lastEffect);
}
// If the drawingRegion is empty, we have something like <g filter=".."/>.
// Even if the target objectBoundingBox() is empty, we still have to draw the last effect result image in postApplyResource.
if (drawingRegion.isEmpty()) {
ASSERT(!m_filter.contains(object));
filterData->savedContext = context;
m_filter.set(object, filterData.leakPtr());
return false;
}
// Change the coordinate transformation applied to the filtered element to reflect the resolution of the filter.
AffineTransform effectiveTransform;
effectiveTransform.scale(scale.width(), scale.height());
effectiveTransform.multiply(filterData->shearFreeAbsoluteTransform);
OwnPtr<ImageBuffer> sourceGraphic;
RenderingMode renderingMode = object->document()->page()->settings()->acceleratedFiltersEnabled() ? Accelerated : Unaccelerated;
if (!SVGImageBufferTools::createImageBuffer(drawingRegion, effectiveTransform, sourceGraphic, ColorSpaceLinearRGB, renderingMode)) {
ASSERT(!m_filter.contains(object));
filterData->savedContext = context;
m_filter.set(object, filterData.leakPtr());
return false;
}
// Set the rendering mode from the page's settings.
filterData->filter->setRenderingMode(renderingMode);
GraphicsContext* sourceGraphicContext = sourceGraphic->context();
ASSERT(sourceGraphicContext);
filterData->sourceGraphicBuffer = sourceGraphic.release();
filterData->savedContext = context;
context = sourceGraphicContext;
ASSERT(!m_filter.contains(object));
m_filter.set(object, filterData.leakPtr());
return true;
}
GPWithRankPrior::GPWithRankPrior(GPCMOptions &inOptions, bool bLoadTrainedModel, bool bRunHighDimensionalOptimization)
{
GPCMOptions options;
//######### initialization_script
if (!inOptions["model"]["initialization_script"].empty())
{
// Options are replaced with the options of the initialization script.
GPCMScriptParser parser(inOptions["model"]["initialization_script"][0],inOptions["dir"]["dir"][0]);
options = parser.getOptions();
// We necessarily want to load the trained model.
bLoadTrainedModel = true;
options["data"]["initialization_file"] = options["result"]["mat_file"];
options["data"]["initialization_file"][0].insert(0,options["dir"]["dir"][0]);
// Override options.
for (GPCMOptions::iterator itr = inOptions.begin(); itr != inOptions.end(); itr++)
{
for (GPCMParams::iterator pitr = itr->second.begin(); pitr != itr->second.end(); pitr++)
{
options[itr->first][pitr->first] = pitr->second;
}
}
}
else if (bLoadTrainedModel)
{ // Set initialization file if we are loading a trained model.
options = inOptions;
options["data"]["initialization_file"] = options["result"]["mat_file"];
options["data"]["initialization_file"][0].insert(0,options["dir"]["dir"][0]);
}
else
{
options = inOptions;
}
GPWithRankPrior *initModel = NULL;
mbHighDimensionalOptimization = bRunHighDimensionalOptimization;
if (!bRunHighDimensionalOptimization &&
!inOptions["embedding"]["training_latent_dimensions"].empty() &&
options["data"]["initialization_file"].empty())
{
// Launch high-dimensional pre-training.
DBPRINTLN("Launching high dimensional optimization...");
initModel = new GPWithRankPrior(options, false, true);
initModel->optimize();
DBPRINTLN("High dimensional optimization complete.");
}
//create data reader
std::string datatype = options["data"]["type"][0];
std::vector<std::string> data = options["data"]["path"];
GPCMDataReader *datareader = NULL;
if (!datatype.compare("bvh_motion")) // Read BVH motion data.
datareader = new GPCMDataReaderBVH();
else if (!datatype.compare("bvh_motion_quat")) // Read BVH motion data but use quaternion representation.
datareader = new GPCMDataReaderBVHQuat();
else if (!datatype.compare("annotation")) // Read ANN annotation data.
datareader = new GPCMDataReaderANN();
else // Unknown data.
DBERROR("Unknown data type " << datatype << " specified!");
std::vector<double> noise(data.size());
for (unsigned i = 0; i < data.size(); i++)
{
if (options["data"]["noise"].size() > i)
noise[i] = atof(options["data"]["noise"][i].c_str());
else
noise[i] = 0.0;
}
// append absloute path
for (std::vector<std::string>::iterator itr = data.begin(); itr != data.end(); itr++)
{
itr->insert(0,options["dir"]["dir"][0]);
}
datareader->load(data,noise);
mDataMatrix = datareader->getYMatrix();
mSequence = datareader->getSequence();
delete datareader;
bool bValidate = !options["optimization"]["validate_gradients"][0].compare("true");
int maxIterations;
if (!options["optimization"]["iterations_lowdim"].empty() && !bRunHighDimensionalOptimization)
maxIterations = atoi(options["optimization"]["iterations_lowdim"][0].c_str());
else
maxIterations = atoi(options["optimization"]["iterations"][0].c_str());
bool bUseEM = !options["model"]["learn_scales"][0].compare("em");
int outerIterations = 1;
if (bUseEM)
outerIterations = atoi(options["optimization"]["outer_iterations"][0].c_str());
if (!options["data"]["initialization_file"].empty())
mbRunOptimization = false;
else
mbRunOptimization = true;
mOptimization = new GPCMOptimization( bValidate, bUseEM, options["optimization"]["algorithm"][0],maxIterations,false);
mLatDim = 1;
if (bRunHighDimensionalOptimization)
mLatDim = atoi(options["embedding"]["training_latent_dimensions"][0].c_str());
else
mLatDim = atoi(options["embedding"]["latent_dimensions"][0].c_str());
if (mLatDim > mDataMatrix.cols()) mLatDim = mDataMatrix.cols();
mX.resize(mDataMatrix.rows(),mLatDim);
mXGrad.resize(mDataMatrix.rows(),mLatDim);
// std::string inittype = options["initialization"]["method"][0];
// Optionally filter the data matrix.
MatrixXd filteredDataMatrix;
if (!options["initialization"]["prefiltering"].empty())
filteredDataMatrix = filterData(mDataMatrix,mSequence,atof(options["initialization"]["prefiltering"][0].c_str()));
else
filteredDataMatrix = mDataMatrix;
mBackConstraint = GPCMBackConstraint::createBackConstraint(options["back_constraints"],options,
mOptimization,mDataMatrix,mX);
MatrixXd *Xptr = &mX;
MatrixXd *Xgradptr = &mXGrad;
mReconstructionGP = new GPCMGaussianProcess(options["model"],options,
mOptimization,NULL,mDataMatrix,mY,&Xptr,&Xgradptr,1,false,true);
// if(!mbHighDimensionalOptimization)
GPCMEmbedPPCA(mX,mDataMatrix);
// else
// mX = mY;
if(mBackConstraint!= nullptr)
mBackConstraint->initialize();
if (mBackConstraint == nullptr)
mOptimization->addVariable(VarXformNone,&mX,&mXGrad,"X");
if (bRunHighDimensionalOptimization && !options["model"]["rank_prior_wt"].empty())
mRankPrior = new GPCMRankPrior(atof(options["model"]["rank_prior_wt"][0].c_str()),mX,mXGrad);
else
mRankPrior = nullptr;
//----------------------------------------------------------------------------------------------
if (initModel)
{
this->copySettings(*initModel);
delete initModel;
}
else if (!options["data"]["initialization_file"].empty())
{
// If we have an initialization file, load that now.
GPCMMatReader *reader = new GPCMMatReader(options["data"]["initialization_file"][0]);
load(reader->getStruct("model"));
delete reader;
}
recompute(true);
}
/*************************************************************
Procedure to collect all data from used NMEA sentences. All
data must be collected first for a valid position
RETURN:
0 All valid GPS data collected
1 Continuing to collect data
2 No data in the buffer
**************************************************************/
uint8_t PA6C::getCoordinates(goCoord *lastKnown)
{
bool startNew = false;
char gpsField[15];
uint8_t charIndex = 0;
uint8_t checksum = 0;
uint8_t checksumR = 0;
uint8_t sentenceID = 0;
uint8_t fieldID = 0;
goCoord currentPosition;
if(!gpsSerial->available()) //no data in the buffer, safe to return
return 2;
unsigned long getGpsData = millis();
while((millis() - getGpsData) < 45 )
{
while(gpsSerial->available())
{
gpsField[charIndex] = gpsSerial->read();
gpsField[charIndex+1] = '\0';
if((gpsField[charIndex] != '$') && (!startNew))
continue;
switch(gpsField[charIndex])
{
case '$':
charIndex = 0;
checksum = 0;
startNew = true;
break;
case ',':
checksum ^= gpsField[charIndex];
gpsField[charIndex] = '\0';
charIndex = 0;
filterData(gpsField, ¤tPosition, &sentenceID, &fieldID); //filter the data
break;
case '*':
checksumR = checksum;
checksum = 0;
charIndex = 0;
filterData(gpsField, ¤tPosition, &sentenceID, &fieldID); //filter the data
break;
case '\r': // used to be \n
break;
case '\n': // used to be \r
checksum = 0;
if((gpsField[0]) >= 48 && (gpsField[0]) <= 57)
checksum = (gpsField[0]-48) << 4;
else
checksum = (gpsField[0]-55) << 4;
if((gpsField[1]) >= 48 && (gpsField[1]) <= 57)
checksum |= (gpsField[1]-48);
else
checksum |= (gpsField[1]-55);
if(checksumR != checksum)
sentenceID = 0x00;
startNew = false;
checksumR = 0;
checksum = 0;
charIndex = 0;
fieldID = 0;
if(sentenceID == 0x0F)
{
if(currentPosition.signalLock)
{
directionOfTravel(¤tPosition);
currentPosition.updated = 0xFF;
*lastKnown = currentPosition;
}
else
lastKnown->signalLock = false;
return 0;
}
break;
default:
checksum ^= gpsField[charIndex];
charIndex++;
break;
}
}
}
return 1; //all data in the buffer processed, but new data is not available
}
int main(int argc, char *argv[])
{
std::cout << "INAV SERVER v" << INAV_VERSION << std::endl;
std::vector<Thread *> threads;
int returnCode;
//Print Help
std::string parsedString = parser( argc, argv, "-h" );
if( parsedString.size() > 0 )
printHelp();
parsedString = parser( argc, argv, "--help" );
if( parsedString.size() > 0 )
printHelp();
//Check for debug
parsedString = parser( argc, argv, "-vv" );
if( parsedString.size() > 0 )
inav::DEBUG = true;
//check log file
if (!inav::log)
{
std::cerr << "Unable to write to log file: " << inav::logFile << std::endl;
exit(-1);
}
log("INAV starting up!");
//check command line options
//check if we should print out pcap capabile devices
parsedString = parser( argc, argv, "-ls" );
if ( parsedString == "set" )
{
log( "Server started with -ls option printing devices and halting..." );
printDevices();
exit(-1);
}
std::string device = parser( argc, argv, "-i" );
if( device == "set" )
{
log( "WARNING: device flag given but no device specified! CANNOT CONTINUE" );
exit( -1 );
}
std::cout << "Device(s) set to " << device << std::endl;
log( "Device(s) set to " + device );
std::vector< std::string > devices;
if( device.size() != 0 )
devices = parseCommas( device );
//Setup pcap file input
std::string file = parser( argc, argv, "-f" );
if( file == "set" )
{
log( "WARNING: input selected as pcap file with no file specified. CANNOT CONTINUE" );
exit( -1 );
}
std::cout << "File(s) set to " << file << std::endl;
log( "File(s) set to " + file );
std::vector< std::string > files;
if( file.size() != 0 )
files = parseCommas( file );
std::string cvsFile = parser( argc, argv, "-c" );
if( cvsFile == "set" )
{
log( "WARNING: input for cvs files is blank. CANNOT CONTINUE" );
exit( -1 );
}
std::cout << "CVSFile(s) Set To " << cvsFile << std::endl;
log( "CVSFILE(s) Set To " + cvsFile );
std::vector< std::string > cvsFiles;
if( cvsFile.size() != 0 )
cvsFiles = parseCommas( cvsFile );
//Creating different datastructures
SnifferData snifferTemplate( inav::coutMutex, inav::logMutex, &inav::log );
snifferTemplate.setDevice( device );
FilterData filterData( inav::coutMutex, inav::logMutex, &inav::log );
GraphData graphData( inav::coutMutex, inav::logMutex, &inav::log );
log( "Creating Sniffer Thread(s)" );
std::vector< std::string >::iterator sitr;
for( sitr = devices.begin(); sitr != devices.end(); ++sitr )
{
//Set up sniffing threads
SnifferDataHolder snifferDataHolder;
SnifferData *snifferData = new SnifferData( snifferTemplate );
snifferData->setDevice( *sitr );
snifferDataHolder.snifferData = snifferData;
snifferDataHolder.filterData = &filterData;
Thread* thread = new Thread( sniffer );
thread->start( (void *) &snifferDataHolder );
threads.push_back( thread );
}
log( "Creating Sniffer Offline Tread(s)" );
for( sitr = files.begin(); sitr != files.end(); ++sitr )
{
//Set up pcap file threads
SnifferDataHolder snifferDataHolder;
SnifferData *snifferData = new SnifferData( snifferTemplate );
snifferData->setDevice( *sitr );
snifferDataHolder.snifferData = snifferData;
snifferDataHolder.filterData = &filterData;
Thread* thread = new Thread( snifferOffline );
thread->start( (void*) &snifferDataHolder );
threads.push_back( thread );
}
log( "Creating cvsFile Input Thread(s) " );
for( sitr = cvsFiles.begin(); sitr != cvsFiles.end(); ++sitr )
{
//Set up pcap file threads
SnifferDataHolder snifferDataHolder;
SnifferData *snifferData = new SnifferData( snifferTemplate );
snifferData->setDevice( *sitr );
snifferDataHolder.snifferData = snifferData;
snifferDataHolder.filterData = &filterData;
Thread* thread = new Thread( cvsSniffer );
thread->start( (void*)&snifferDataHolder );
threads.push_back( thread );
}
//Set up Bandwidth Monitor Thread
BandwidthDataHolder bandwidthDataHolder;
bandwidthDataHolder.filterData = &filterData;
bandwidthDataHolder.graphData = &graphData;
log( "Creating Bandwidth Monitor Thread" );
Thread* thread = new Thread( bandwidthMonitor );
thread->start( (void*)&bandwidthDataHolder );
threads.push_back( thread );
//Set up client thread
std::string port = parser( argc, argv, "-p" );
int portnum = communication::ServerPort;
if( port.size() > 0 )
{
log( "Seting port to " + port );
portnum = atoi( port.c_str() );
}
ClientCommData clientCommData( inav::coutMutex, inav::logMutex, &inav::log, portnum );
clientCommData.filterData = &filterData;
clientCommData.graphData = &graphData;
log( "Creating Communication Thread" );
thread = new Thread( communicationChannel );
thread->start( (void*)&clientCommData );
threads.push_back( thread );
std::string debug = parser( argc, argv, "--debug" );
if( debug.size() > 0 )
{
DebugData debugData;
debugData.filterData = &filterData;
debugData.graphData = &graphData;
Thread* thread = new Thread( debugThread );
thread->start( (void*)&debugData );
threads.push_back( thread );
}
//Wait for threads to exit
//(void*)
std::vector<Thread*>::iterator itr;
for( itr = threads.begin(); itr != threads.end(); ++itr )
{
log( "Deleting Thread... " );
(*itr)->join();
}
log( "INAV server halting!" );
return 0;
}
static void
abv_getdata(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int result; /* return values for called function */
mxArray *pArray; /* generic pointer to a matlab array */
int lastBlock; /* the last block which we have seen */
int nChannels; /* number of channels */
int blocksize; /* the size of blocks */
int ElementSize; /* size of one data point. 2 if int16, 4 if int32, etc */
int reconnect; /* if we reconnect on connection loss */
char *bv_hostname = 0; /* if we reconnect wi need the hostname */
struct RDA_MessageData *pMsgData;
struct RDA_MessageStart *pMsgStart;
/* init the input and output values */
const mxArray* IN_STATE = prhs[0];
mxArray* OUT_DATA = NULL;
mxArray* OUT_MRK_TIME = NULL;
mxArray* OUT_MRK_DESCR = NULL;
mxArray* OUT_STATE = NULL;
/* get the information from the state and obtain the data */
lastBlock = (int)getScalar(IN_STATE, FIELD_BLOCK_NO);
nChannels = getArrayN(IN_STATE, FIELD_CLAB);
result = getData(&pMsgData, &blocksize, lastBlock, nChannels, &ElementSize);
/* If everything is okay, construct the appropriate output. Else
* return empty arrays.
*/
if (result != -1) {
int n;
int nChans_orig, lag, nPoints, nChans_sel, nMarkers, pDstPosition;
double *chan_sel, *scale, *pDst0, *pMrkPos, *pSrcDouble;
struct RDA_Marker *pMarker;
char *pszType, *pszDesc;
char* outputTypeDef;
int outputType;
double *pMrkToe;
/* get necessary information from the current state */
nChans_orig = getArrayN(IN_STATE, FIELD_CLAB);
lag = (int) getScalar(IN_STATE,FIELD_LAG);
nPoints = (getFIRPos() + pMsgData->nPoints)/lag;
chan_sel = getArray(IN_STATE, FIELD_CHAN_SEL);
nChans_sel = getArrayN(IN_STATE, FIELD_CHAN_SEL);
/* check for the new resample filter */
abv_assert(checkArray(IN_STATE, FIELD_FILT_SUBSAMPLE, 1, lag), "bbci_acquire_bv: Resample filter has to be a vector. Resample filter has to correspondent with the sampling rate.");
filterFIRSet(getArray(IN_STATE, FIELD_FILT_SUBSAMPLE));
/* construct the data output matrix. */
OUT_DATA = mxCreateDoubleMatrix(nPoints, nChans_sel, mxREAL);
pArray = mxGetField(IN_STATE, 0, "scale");
scale = mxGetPr(pArray);
pDst0= mxGetPr(OUT_DATA);
pDstPosition = 0;
/* convert the source data to double format */
pSrcDouble = (double*)malloc(pMsgData->nPoints * nChans_orig * sizeof(double));
if (ElementSize==2) {
int16_t *pSrc = pMsgData->nData;
for(n = 0; n != pMsgData->nPoints * nChans_orig; ++n) {
pSrcDouble[n] = (double)pSrc[n];
}
} else if (ElementSize==4) {
int32_t *pSrc = (int32_t*) pMsgData->nData;
for(n = 0; n != pMsgData->nPoints * nChans_orig; ++n) {
pSrcDouble[n] = (double)pSrc[n];
}
} else {
mexErrMsgTxt("bbci_acquire_bv: Unknown element size");
}
/* filter the data with the filters */
filterData(pSrcDouble,pMsgData->nPoints ,pDst0,nPoints, chan_sel, nChans_sel, scale);
free(pSrcDouble);
/* if markers are also requested, construct the appropriate output
matrices */
if (nlhs >= 2) {
nMarkers = pMsgData->nMarkers;
if (nMarkers > 0) {
/* if markers existed, collect them */
OUT_MRK_TIME = mxCreateDoubleMatrix(1, nMarkers, mxREAL);
pMrkPos = mxGetPr(OUT_MRK_TIME);
outputTypeDef = getString(IN_STATE, FIELD_MARKER_FORMAT);
if(0 == strcmp ("numeric", outputTypeDef)) {
outputType = 1;
} else if(0 == strcmp ("string", outputTypeDef)) {
outputType = 2;
} else {
mexErrMsgTxt("bbci_acquire_bv: Unknown ouput type.");
}
free(outputTypeDef);
if (nlhs >= 3) {
if(1 == outputType) { /* numeric */
OUT_MRK_DESCR = mxCreateDoubleMatrix(1, nMarkers, mxREAL);
pMrkToe = mxGetPr(OUT_MRK_DESCR);
} else if(2 == outputType) {/* string */
OUT_MRK_DESCR = mxCreateCellMatrix(1,nMarkers);
} else {
mexErrMsgTxt("bbci_acquire_bv: Unknown ouput type for output.");
}
}
pMarker = (struct RDA_Marker*)((char*)pMsgData->nData + pMsgData->nPoints * nChans_orig * ElementSize);
double origFs = getScalar(IN_STATE, FIELD_ORIG_FS);
for (n = 0; n < nMarkers; n++) {
pMrkPos[n]= ((double)pMarker->nPosition+1.0) * 1000.0 /origFs;
pszType = pMarker->sTypeDesc;
pszDesc = pszType + strlen(pszType) + 1;
if (nlhs >= 3) {
if(1 == outputType) { /* numeric */
pMrkToe[n]= ((*pszDesc =='R') ? -1 : 1) * atoi(pszDesc+1);
} else if(2 == outputType) {/* string */
mxSetCell(OUT_MRK_DESCR, n, mxCreateString(pszDesc));
} else {
mexErrMsgTxt("bbci_acquire_bv: Unknown ouput type for output.");
}
}
pMarker = (struct RDA_Marker*)((char*)pMarker + pMarker->nSize);
}
}
else {
/* no markers -> return empty matrix */
OUT_MRK_TIME = mxCreateDoubleMatrix(0, 0, mxREAL);
if (nlhs >= 3) {
OUT_MRK_DESCR = mxCreateDoubleMatrix(0, 0, mxREAL);
}
}
} /* end constructing marker outputs */
}
else {
int nChans_sel;
reconnect = (int) getScalar(IN_STATE, FIELD_RECONNECT);
if(1 == reconnect) {
printf("bbci_acquire_bv: getData didn't work, reconnecting ");
/* only close the connection */
closeConnection();
connected = 0;
bv_hostname = (char *) malloc(MAX_CHARS);
/* getting the hostname for the new connection */
pArray = mxGetField(IN_STATE, 0, "hostname");
mxGetString(pArray, bv_hostname, MAX_CHARS);
free(pMsgData);
/* try reconnecting till we get a new connection */
while(IC_OKAY != (result = initConnection(bv_hostname, &pMsgStart))){
printf("bbci_acquire_bv: connecting failed, trying again\n");
free(pMsgData);
}
/* cleaning things up */
free(bv_hostname);
free(pMsgStart);
connected = 1;
} else {
printf("bbci_acquire_bv: getData didn't work, closing connection, returning -2\n ");
/* close the connection and clean everything up */
abv_close();
}
/* We have an error in the data transmition return an empty datablock. */
pArray = mxGetField(IN_STATE, 0, "chan_sel");
nChans_sel = mxGetN(pArray);
OUT_DATA = mxCreateDoubleMatrix(0, nChans_sel, mxREAL);
if (nlhs >= 2){OUT_MRK_TIME = mxCreateDoubleMatrix(0,0, mxREAL);};
if (nlhs >= 3){OUT_MRK_DESCR = mxCreateDoubleMatrix(0,0, mxREAL);};
}
/* clone the state */
if(nlhs >= 4) {OUT_STATE = mxDuplicateArray(IN_STATE);};
plhs[0] = OUT_DATA;
if(nlhs >=2) {
plhs[1] = OUT_MRK_TIME;
}
if(nlhs >=3) {
plhs[2] = OUT_MRK_DESCR;
}
if(nlhs >=4) {
plhs[3] = OUT_STATE;
}
free(pMsgData);
}
uint16_t analogRead(uint8_t pinNum)
{
if (pinNum > 7) return 0;
else return filterData(&adc_data[pinNum][0]);
}
/*What will happen when pressed ENTER while standing on chosen area*/
void pMAction(int aChar)
{
if (strcmp(mapName, "menu") == 0)
{
switch (aChar)
{
case 1:
break;
case 0:
useDoor(E, UP);
useDoor(F, DOWN);
useDoor(H, LEFT);
useDoor(G, RIGHT);
break;
}
}
else if (strcmp(mapName, "sorting") == 0)
{
switch (aChar)
{
case 1:
sortData(1, v_order);
break;
case 2:
sortData(2, v_order);
break;
case 3:
sortData(3, v_order);
break;
case 4:
sortData(4, v_order);
break;
case 5:
sortData(5, v_order);
break;
case O:
initializeData();
break;
case U:
v_order = UP;
break;
case D:
v_order = DOWN;
break;
/*@*/
case (64-48):
switchMap("menu");
break;
}
}
else if (strcmp(mapName, "filtering") == 0)
{
switch (aChar)
{
case O:
loadGlobalActions(mapName);
activateDatabase(movies_database);
initializeData();
cMAppearance(U, 0, 0, ' ');
cMAppearance(I, 0, 0, ' ');
break;
case Z:
if (action1 == 1 && action2 == FALSE)
break;
if (action1 != FALSE)
{
passValue(column1, &action2);
teleport (U);
openDoor(Q, DOWN);
if (action2 != FALSE)
cMAppearance(U, 0, 0, '*');
}
else
{
passValue(column1, &action1);
teleport (I);
openDoor(W, UP);
if (action1 != FALSE)
cMAppearance(I, 0, 0, '*');
}
break;
case X:
if (action1 == 2 && action2 == FALSE)
break;
if (action1 != FALSE)
{
passValue(column2, &action2);
teleport (U);
openDoor(Q, DOWN);
if (action2 != FALSE)
cMAppearance(U, 0, 0, '*');
}
else
{
passValue(column2, &action1);
teleport (I);
openDoor(W, UP);
if (action1 != FALSE)
cMAppearance(I, 0, 0, '*');
}
break;
case C:
if (action1 == 3 && action2 == FALSE)
break;
if (action1 != FALSE)
{
passValue(column3, &action2);
teleport (U);
openDoor(Q, DOWN);
if (action2 != FALSE)
cMAppearance(U, 0, 0, '*');
}
else
{
passValue(column3, &action1);
teleport (I);
openDoor(W, UP);
if (action1 != FALSE)
cMAppearance(I, 0, 0, '*');
}
break;
case V:
if (action1 == 4 && action2 == FALSE)
break;
if (action1 == TRUE)
{
passValue(column4, &action2);
teleport (U);
openDoor(Q, DOWN);
if (action2 != FALSE)
cMAppearance(U, 0, 0, '*');
}
else
{
passValue(column4, &action1);
teleport (I);
openDoor(W, UP);
if (action1 != FALSE)
cMAppearance(I, 0, 0, '*');
}
break;
case B:
if (action1 == 5 && action2 == FALSE)
break;
if (action1 != FALSE)
{
passValue(column5, &action2);
teleport (U);
openDoor(Q, DOWN);
if (action2 != FALSE)
cMAppearance(U, 0, 0, '*');
}
else
{
passValue(column5, &action1);
teleport (I);
openDoor(W, UP);
if (action1 != FALSE)
cMAppearance(I, 0, 0, '*');
}
break;
case 6:
useDoor(E, RIGHT);
break;
case 9:
switch (action1)
{
case 1:
switch (action2)
{
case 2:
filterData(action1, v_column1, action2, v_column2);
break;
case 3:
filterData(action1, v_column1, action2, v_column3);
break;
case 4:
filterData(action1, v_column1, action2, v_column4);
break;
case 5:
filterData(action1, v_column1, action2, v_column5);
break;
}
break;
case 2:
switch (action2)
{
case 1:
filterData(action1, v_column2, action2, v_column1);
break;
case 3:
filterData(action1, v_column2, action2, v_column3);
break;
case 4:
filterData(action1, v_column2, action2, v_column4);
break;
case 5:
filterData(action1, v_column2, action2, v_column5);
break;
}
break;
case 3:
switch (action2)
{
case 1:
filterData(action1, v_column3, action2, v_column1);
break;
case 2:
filterData(action1, v_column3, action2, v_column2);
break;
case 4:
filterData(action1, v_column3, action2, v_column4);
break;
case 5:
filterData(action1, v_column3, action2, v_column5);
break;
}
break;
case 4:
switch (action2)
{
case 1:
filterData(action1, v_column4, action2, v_column1);
break;
case 2:
filterData(action1, v_column4, action2, v_column2);
break;
case 3:
filterData(action1, v_column4, action2, v_column3);
break;
case 5:
filterData(action1, v_column4, action2, v_column5);
break;
}
break;
case 5:
switch (action2)
{
case 1:
filterData(action1, v_column5, action2, v_column1);
break;
case 2:
filterData(action1, v_column5, action2, v_column2);
break;
case 3:
filterData(action1, v_column5, action2, v_column3);
break;
case 4:
filterData(action1, v_column5, action2, v_column4);
break;
}
break;
}
break;
/*@*/
case (64-48):
switchMap("menu");
break;
}
}
else
{
perror ("'mapName' out of speck");
SC(mapName);
assert(!TRUE);
}
mapConditions();
}
int main()
{
filterData();
return 0;
}
