Exemplo n.º 1
0
int main(int argc, char *argv[])
{
    bool hasTouchScreen = QFile::exists("/sys/devices/platform/rpi_ft5406");

    // Unless we have a touch screen, wait for keyboard to appear before displaying anything
    if (!hasTouchScreen)
        KeyDetection::waitForKeyboard();

    int rev = readBoardRevision();

    qDebug() << "Board revision is " << rev;

    int gpioChannel;

    if (rev == 2 || rev == 3)
        gpioChannel = 0;
    else
        gpioChannel = 2;

    QApplication a(argc, argv);
    RightButtonFilter rbf;
    LongPressHandler lph;
    GpioInput gpio(gpioChannel);

    bool runinstaller = false;
    bool gpio_trigger = false;
    bool keyboard_trigger = true;
    bool force_trigger = false;

    QString defaultLang = "en";
    QString defaultKeyboard = "gb";
    QString defaultDisplay = "0";
    QString defaultPartition = "800";

    // Process command-line arguments
    for (int i=1; i<argc; i++)
    {
        // Flag to indicate first boot
        if (strcmp(argv[i], "-runinstaller") == 0)
            runinstaller = true;
        // Enables use of GPIO 3 to force NOOBS to launch by pulling low
        else if (strcmp(argv[i], "-gpiotriggerenable") == 0)
            gpio_trigger = true;
        // Disables use of keyboard to trigger recovery GUI
        else if (strcmp(argv[i], "-keyboardtriggerdisable") == 0)
            keyboard_trigger = false;
        // Forces display of recovery GUI every time
        else if (strcmp(argv[i], "-forcetrigger") == 0)
            force_trigger = true;
        // Allow default language to be specified in commandline
        else if (strcmp(argv[i], "-lang") == 0)
        {
            if (argc > i+1)
                defaultLang = argv[i+1];
        }
        // Allow default keyboard layout to be specified in commandline
        else if (strcmp(argv[i], "-kbdlayout") == 0)
        {
            if (argc > i+1)
                defaultKeyboard = argv[i+1];
        }
        // Allow default display mode to be specified in commandline
        else if (strcmp(argv[i], "-dispmode") == 0)
        {
            if (argc > i+1)
                defaultDisplay = --argv[i+1];
        }
        // Allow default boot partition to be specified in commandline
        else if (strcmp(argv[i], "-partition") == 0)
        {
            if (argc > i+1)
                defaultPartition = argv[i+1];
        }
    }

    // Intercept right mouse clicks sent to the title bar
    a.installEventFilter(&rbf);

    // Treat long holds as double-clicks
    if (hasTouchScreen)
        a.installEventFilter(&lph);

#ifdef Q_WS_QWS
    QWSServer::setCursorVisible(false);
#endif

    QDir settingsdir;
    settingsdir.mkdir("/settings");

    // Set wallpaper and icon, if we have resource files for that
    if (QFile::exists(":/icons/raspberry_icon.png"))
        a.setWindowIcon(QIcon(":/icons/raspberry_icon.png"));

#ifdef Q_WS_QWS
    QWSServer::setBackground(BACKGROUND_COLOR);
#endif
    QSplashScreen *splash = new QSplashScreen(QPixmap(":/wallpaper.png"));
    splash->show();
    QApplication::processEvents();

    // Wait for drive device to show up
    QString drive;
    bool driveReady = false;
    QTime t;
    t.start();

    while (t.elapsed() < 10000)
    {
        if (drive.isEmpty())
        {
            /* We do not know the exact drive name to wait for */
            drive = findRecoveryDrive();
            if (!drive.isEmpty())
            {
                driveReady = true;
                break;
            }
        }
        else if (drive.startsWith("/dev"))
        {
            if (QFile::exists(drive))
            {
                driveReady = true;
                break;
            }
        }

        QApplication::processEvents(QEventLoop::WaitForMoreEvents, 100);
    }
    if (!driveReady)
    {
        QMessageBox::critical(NULL, "Files not found", QString("Cannot find the drive with NOOBS files %1").arg(drive), QMessageBox::Close);
        return 1;
    }
    qDebug() << "NOOBS drive:" << drive;

    // If -runinstaller is not specified, only continue if SHIFT is pressed, GPIO is triggered,
    // or no OS is installed (/settings/installed_os.json does not exist)
    bool bailout = !runinstaller
        && !force_trigger
        && !(gpio_trigger && (gpio.value() == 0 ))
        && hasInstalledOS(drive);

    if (bailout && keyboard_trigger)
    {
        t.start();

        while (t.elapsed() < 2000)
        {
            QApplication::processEvents(QEventLoop::WaitForMoreEvents, 10);
            if (QApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier))
            {
                bailout = false;
                qDebug() << "Shift detected";
                break;
            }
            if (hasTouchScreen && QApplication::mouseButtons().testFlag(Qt::LeftButton))
            {
                bailout = false;
                qDebug() << "Tap detected";
                break;
            }
        }
    }

    if (bailout)
    {
        splash->hide();
        showBootMenu(drive, defaultPartition, true);
    }

#ifdef Q_WS_QWS
    QWSServer::setCursorVisible(true);
#endif

    // Main window in the middle of screen
    MainWindow mw(drive, defaultDisplay, splash);
    mw.setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, mw.size(), a.desktop()->availableGeometry()));
    mw.show();

#ifdef ENABLE_LANGUAGE_CHOOSER
     // Language chooser at the bottom center
    LanguageDialog* ld = new LanguageDialog(defaultLang, defaultKeyboard);
    ld->setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignHCenter | Qt::AlignBottom, ld->size(), a.desktop()->availableGeometry()));
    ld->show();
#endif

    a.exec();
    showBootMenu(drive, defaultPartition, false);

    return 0;
}
Exemplo n.º 2
0
int main(int argc,char *argv[])
{
  QApplication a(argc,argv,false);
  new MainObject(NULL,"main");
  return a.exec();
}
void Foam::threePhaseInterfaceProperties::correctContactAngle
(
    surfaceVectorField::GeometricBoundaryField& nHatb
) const
{
    const volScalarField::GeometricBoundaryField& alpha1 =
        mixture_.alpha1().boundaryField();
    const volScalarField::GeometricBoundaryField& alpha2 =
        mixture_.alpha2().boundaryField();
    const volScalarField::GeometricBoundaryField& alpha3 =
        mixture_.alpha3().boundaryField();
    const volVectorField::GeometricBoundaryField& U =
        mixture_.U().boundaryField();

    const fvMesh& mesh = mixture_.U().mesh();
    const fvBoundaryMesh& boundary = mesh.boundary();

    forAll(boundary, patchi)
    {
        if (isA<alphaContactAngleFvPatchScalarField>(alpha1[patchi]))
        {
            const alphaContactAngleFvPatchScalarField& a2cap =
                refCast<const alphaContactAngleFvPatchScalarField>
                (alpha2[patchi]);

            const alphaContactAngleFvPatchScalarField& a3cap =
                refCast<const alphaContactAngleFvPatchScalarField>
                (alpha3[patchi]);

            scalarField twoPhaseAlpha2(max(a2cap, scalar(0)));
            scalarField twoPhaseAlpha3(max(a3cap, scalar(0)));

            scalarField sumTwoPhaseAlpha
            (
                twoPhaseAlpha2 + twoPhaseAlpha3 + SMALL
            );

            twoPhaseAlpha2 /= sumTwoPhaseAlpha;
            twoPhaseAlpha3 /= sumTwoPhaseAlpha;

            fvsPatchVectorField& nHatp = nHatb[patchi];

            scalarField theta
            (
                convertToRad
              * (
                   twoPhaseAlpha2*(180 - a2cap.theta(U[patchi], nHatp))
                 + twoPhaseAlpha3*(180 - a3cap.theta(U[patchi], nHatp))
                )
            );

            vectorField nf(boundary[patchi].nf());

            // Reset nHatPatch to correspond to the contact angle

            scalarField a12(nHatp & nf);

            scalarField b1(cos(theta));

            scalarField b2(nHatp.size());

            forAll(b2, facei)
            {
                b2[facei] = cos(acos(a12[facei]) - theta[facei]);
            }

            scalarField det(1.0 - a12*a12);

            scalarField a((b1 - a12*b2)/det);
            scalarField b((b2 - a12*b1)/det);

            nHatp = a*nf + b*nHatp;

            nHatp /= (mag(nHatp) + deltaN_.value());
        }
    }
Exemplo n.º 4
0
int main(int argc, char *argv[])
{
	int ret = 0;
	struct sr_context *sr_ctx = NULL;
	const char *open_file = NULL;

	QApplication a(argc, argv);

	// Set some application metadata
    QApplication::setApplicationVersion(DS_VERSION_STRING);
    QApplication::setApplicationName("DSLogic");
    QApplication::setOrganizationDomain("http://www.DreamSourceLab.com");

	// Parse arguments
	while (1) {
		static const struct option long_options[] = {
			{"loglevel", required_argument, 0, 'l'},
			{"version", no_argument, 0, 'V'},
			{"help", no_argument, 0, 'h'},
			{0, 0, 0, 0}
		};

		const int c = getopt_long(argc, argv,
			"l:Vh?", long_options, NULL);
		if (c == -1)
			break;

		switch (c) {
		case 'l':
		{
			const int loglevel = atoi(optarg);
			sr_log_loglevel_set(loglevel);

#ifdef ENABLE_SIGROKDECODE
			srd_log_loglevel_set(loglevel);
#endif

			break;
		}

		case 'V':
			// Print version info
			fprintf(stdout, "%s %s\n", DS_TITLE, DS_VERSION_STRING);
			return 0;

		case 'h':
		case '?':
			usage();
			return 0;
		}
	}

	if (argc - optind > 1) {
		fprintf(stderr, "Only one file can be openened.\n");
		return 1;
	} else if (argc - optind == 1)
		open_file = argv[argc - 1];

	// Initialise libsigrok
	if (sr_init(&sr_ctx) != SR_OK) {
		qDebug() << "ERROR: libsigrok init failed.";
		return 1;
	}

	do {

#ifdef ENABLE_SIGROKDECODE
		// Initialise libsigrokdecode
		if (srd_init(NULL) != SRD_OK) {
			qDebug() << "ERROR: libsigrokdecode init failed.";
			break;
		}

		// Load the protocol decoders
		srd_decoder_load_all();
#endif

		try {
			// Create the device manager, initialise the drivers
			pv::DeviceManager device_manager(sr_ctx);

			// Initialise the main window
            pv::MainWindow w(device_manager, open_file);
            //QFile qss(":/levelfour.qss");
            QFile qss(":/stylesheet.qss");
            qss.open(QFile::ReadOnly);
            a.setStyleSheet(qss.readAll());
            qss.close();
			w.show();

			// Run the application
			ret = a.exec();

		} catch(std::exception e) {
			qDebug() << e.what();
		}

#ifdef ENABLE_SIGROKDECODE
		// Destroy libsigrokdecode
		srd_exit();
#endif

	} while (0);

	// Destroy libsigrok
	if (sr_ctx)
		sr_exit(sr_ctx);

	return ret;
}
Exemplo n.º 5
0
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
	QStringList args = a.arguments();
	if (args.size() < 3) {
		QStringList usage;
		usage << args.at(0)
			  << "[train data]"
			  << "[test data]";
		qFatal("Too few arguments. Usage:\n%s\n", usage.join(" ").toStdString().c_str());
	}

	QFile trainFile(args.at(1));
	if (!trainFile.open(QIODevice::ReadOnly)) {
		qFatal("Failed to open train file %s.\n", trainFile.fileName().toStdString().c_str());
	}
	QFile testFile(args.at(2));
	if (!testFile.open(QIODevice::ReadOnly)) {
		qFatal("Failed to open test file %s.\n", testFile.fileName().toStdString().c_str());
	}

    QElapsedTimer loadTimer;
    loadTimer.start();
    FeatureImporter trainFeatures;
    FeatureImporter testFeatures;
#pragma omp sections
    {
#pragma omp section
        {
            trainFeatures.open(&trainFile);
        }
#pragma omp section
        {
            testFeatures.open(&testFile);
        }
    }
    int loadMsecs = loadTimer.elapsed();
    qDebug() << "loading took" << loadMsecs << "msecs";

	trainFile.close();
	testFile.close();

	QVector<QString> hash;
    QVector<qint8> trainClasses;
	for (int i = 0; i < trainFeatures.labels().size(); i++) {
        qint8 index = hash.indexOf(trainFeatures.labels().at(i));
		if (index == -1) {
			QString dbg("Appending label \"%1\" to hash at position %2. It has now value \"%3\"");
			hash.append(trainFeatures.labels().at(i));
			index = hash.size() - 1;
			//qDebug() << dbg.arg(trainFeatures.labels().at(i), QString::number(index), hash.at(index));
		}
		trainClasses.append(index);
	}

    ClassifierInterface *ci = new CpuClassifier();
    QVector<QVector<int> > classes;
    qDebug() << "starting classification";
    QList<int> k;

    bool ok = true;
    int i = 50;
    if (args.size() >= 4) {
        i = qMax(0, args.at(3).toInt(&ok));
    } else {
        ok = false;
    }
    if (!ok) {
        qDebug() << "no k given, assuming k = 50";
        i = 50;
    }
    qDebug() << "initial k:" << i;
    for (; i >= 1; i--) {
        k.append(i);
    }
    QElapsedTimer timer;
    timer.start();
	classes = ci->classify(trainFeatures.features(), testFeatures.features(),
						   trainClasses.constData(), NULL,
						   testFeatures.featuresPerItem(),
						   trainFeatures.itemCount(), testFeatures.itemCount(),
                           k);
    delete ci;
	int msecs = timer.elapsed();
	qDebug() << "calculations took" << msecs << "msecs";
    for (int w = 0; w < classes.size(); w++) {
        int correct = 0;
        QVector<QVector<qreal> > confusionMatrix;
        confusionMatrix.resize(hash.size());
        for (int i = 0; i < confusionMatrix.size(); i++) {
            confusionMatrix[i].resize(hash.size());
        }
        for (int i = 0; i < classes.at(w).size(); i++) {
            /*qDebug() << i;
            qDebug() << classes.at(i);
            qDebug() << hash.at(classes.at(i));
            qDebug() << testFeatures.labels().at(i);*/
            confusionMatrix[hash.indexOf(testFeatures.labels().at(i))][classes.at(w).at(i)]++;
            /*if (hash.at(classes.at(w).at(i)) == QString("5")) {
                qDebug() << "is 5, should be " << testFeatures.labels().at(i);
            }*/
            if (hash.at(classes.at(w).at(i)) == testFeatures.labels().at(i)) {
                correct++;
            }
        }
        QVector<QPair<QString, int> > sorter;
        for (int i = 0; i < hash.size(); i++) {
            sorter << qMakePair(hash.at(i), i);
        }
        qSort(sorter);
        QStringList l;
        for (int i = 0; i < hash.size(); i++) {
            l << sorter.at(i).first;
        }
        QVector<QVector<qreal> > tempConfusionMatrix;
        tempConfusionMatrix.resize(hash.size());
        for (int j = 0; j < confusionMatrix.size(); j++) {
            for (int i = 0; i < sorter.size(); i++) {
                tempConfusionMatrix[j] << confusionMatrix.at(j).at(sorter.at(i).second);
            }
        }
        confusionMatrix = tempConfusionMatrix;
        for (int j = 0; j < confusionMatrix.size(); j++) {
            tempConfusionMatrix[j] = confusionMatrix.at(sorter.at(j).second);
        }
        confusionMatrix = tempConfusionMatrix;
#ifdef PERCENTAGE_CONFUSION
        for (int i = 0; i < confusionMatrix.size(); i++) {
            qreal sum = 0;
            for (int j = 0; j < confusionMatrix.at(i).size(); j++) {
                sum += confusionMatrix.at(j).at(i);
            }
            for (int j = 0; j < confusionMatrix.at(i).size(); j++) {
                confusionMatrix[j][i] = confusionMatrix.at(j).at(i) / sum * 100.0;
            }
        }
#endif
        QTextStream stream(stdout);
        stream << "k: " << k.at(w) << endl;
        stream << "\t&\t" << l.join("\t&\t") << "\\\\" << endl;
        for (int i = 0; i < confusionMatrix.size(); i++) {
            QStringList list;
            list << sorter.at(i).first;
            for (int j = 0; j < confusionMatrix.size(); j++) {
                list << QString::number(confusionMatrix[i][j], 'g', 4);
            }
            const QString joined(list.join("\t&\t"));
            stream << joined << "\\\\" << endl;
        }
        stream << "correct: " << ((float)correct / (float)classes.at(w).size()) * 100 << "%" << endl;
    }
    msecs = timer.elapsed();
    qDebug() << "everything took" << msecs << "msecs";
	return 0;
}
Exemplo n.º 6
0
Arquivo: main.cpp Projeto: CCJY/coliru
int main() {
    Type type;
    type.destructor = [] (Value* self) { std::cout << "destroying " << self << "!\n"; };
    boost::intrusive_ptr<Value> a(new Value);
    a->type = &type;
}
Exemplo n.º 7
0
int main()
{
    AA aa;
    AA a(aa);
    return 0;
}
/*************************************************************************
Testing symmetric EVD subroutine
*************************************************************************/
bool testsevd(bool silent)
{
    bool result;
    ap::real_2d_array a;
    ap::real_2d_array al;
    ap::real_2d_array au;
    ap::real_2d_array z;
    int pass;
    int n;
    int i;
    int j;
    int mkind;
    int passcount;
    int maxn;
    double materr;
    double valerr;
    double orterr;
    bool wnsorted;
    int failc;
    int runs;
    double failr;
    double failthreshold;
    double threshold;
    bool waserrors;
    bool wfailed;

    failthreshold = 0.005;
    threshold = 1000*ap::machineepsilon;
    materr = 0;
    valerr = 0;
    orterr = 0;
    wnsorted = false;
    wfailed = false;
    failc = 0;
    runs = 0;
    maxn = 20;
    passcount = 10;
    
    //
    // Main cycle
    //
    for(n = 1; n <= maxn; n++)
    {
        
        //
        // Prepare
        //
        a.setbounds(0, n-1, 0, n-1);
        al.setbounds(0, n-1, 0, n-1);
        au.setbounds(0, n-1, 0, n-1);
        for(i = 0; i <= n-1; i++)
        {
            for(j = i+1; j <= n-1; j++)
            {
                
                //
                // A
                //
                a(i,j) = 2*ap::randomreal()-1;
                a(j,i) = a(i,j);
                
                //
                // A lower
                //
                al(i,j) = 2*ap::randomreal()-1;
                al(j,i) = a(i,j);
                
                //
                // A upper
                //
                au(i,j) = a(i,j);
                au(j,i) = 2*ap::randomreal()-1;
            }
            a(i,i) = 2*ap::randomreal()-1;
            al(i,i) = a(i,i);
            au(i,i) = a(i,i);
        }
        
        //
        // Test
        //
        testevdproblem(a, al, au, n, materr, valerr, orterr, wnsorted, failc);
        runs = runs+1;
    }
    
    //
    // report
    //
    failr = double(failc)/double(runs);
    wfailed = failr>failthreshold;
    waserrors = materr>threshold||valerr>threshold||orterr>threshold||wnsorted||wfailed;
    if( !silent )
    {
        printf("TESTING SYMMETRIC EVD\n");
        printf("EVD matrix error:                        %5.3le\n",
            double(materr));
        printf("EVD values error (different variants):   %5.3le\n",
            double(valerr));
        printf("EVD orthogonality error:                 %5.3le\n",
            double(orterr));
        printf("Eigen values order:                      ");
        if( !wnsorted )
        {
            printf("OK\n");
        }
        else
        {
            printf("FAILED\n");
        }
        printf("Always converged:                        ");
        if( !wfailed )
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
            printf("Fail ratio:                              %5.3lf\n",
                double(failr));
        }
        printf("Threshold:                               %5.3le\n",
            double(threshold));
        if( waserrors )
        {
            printf("TEST FAILED\n");
        }
        else
        {
            printf("TEST PASSED\n");
        }
        printf("\n\n");
    }
    result = !waserrors;
    return result;
}
Exemplo n.º 9
0
void SvgElementVisitor::visit(clan::DomElement &e)
{
	if (e.get_namespace_uri() != Svg::svg_ns) return;

	// To do: do a more efficient search for the correct handler

	auto local_name = e.get_local_name();
	if (local_name == "a") a(e);
	else if (local_name == "altGlyph") altGlyph(e);
	else if (local_name == "altGlyphDef") altGlyphDef(e);
	else if (local_name == "altGlyphItem") altGlyphItem(e);
	else if (local_name == "animate") animate(e);
	else if (local_name == "animateColor") animateColor(e);
	else if (local_name == "animateMotion") animateMotion(e);
	else if (local_name == "animateTransform") animateTransform(e);
	else if (local_name == "circle") circle(e);
	else if (local_name == "clipPath") clipPath(e);
	else if (local_name == "color-profile") color_profile(e);
	else if (local_name == "cursor") cursor(e);
	else if (local_name == "defs") defs(e);
	else if (local_name == "desc") desc(e);
	else if (local_name == "ellipse") ellipse(e);
	else if (local_name == "feBlend") feBlend(e);
	else if (local_name == "feColorMatrix") feColorMatrix(e);
	else if (local_name == "feComponentTransfer") feComponentTransfer(e);
	else if (local_name == "feComposite") feComposite(e);
	else if (local_name == "feConvolveMatrix") feConvolveMatrix(e);
	else if (local_name == "feDiffuseLighting") feDiffuseLighting(e);
	else if (local_name == "feDisplacementMap") feDisplacementMap(e);
	else if (local_name == "feDistantLight") feDistantLight(e);
	else if (local_name == "feFlood") feFlood(e);
	else if (local_name == "feFuncA") feFuncA(e);
	else if (local_name == "feFuncB") feFuncB(e);
	else if (local_name == "feFuncG") feFuncG(e);
	else if (local_name == "feFuncR") feFuncR(e);
	else if (local_name == "feGaussianBlur") feGaussianBlur(e);
	else if (local_name == "feImage") feImage(e);
	else if (local_name == "feMerge") feMerge(e);
	else if (local_name == "feMergeNode") feMergeNode(e);
	else if (local_name == "feMorphology") feMorphology(e);
	else if (local_name == "feOffset") feOffset(e);
	else if (local_name == "fePointLight") fePointLight(e);
	else if (local_name == "feSpecularLighting") feSpecularLighting(e);
	else if (local_name == "feSpotLight") feSpotLight(e);
	else if (local_name == "feTile") feTile(e);
	else if (local_name == "feTurbulence") feTurbulence(e);
	else if (local_name == "filter") filter(e);
	else if (local_name == "font") font(e);
	else if (local_name == "font-face") font_face(e);
	else if (local_name == "font-face-format") font_face_format(e);
	else if (local_name == "font-face-name") font_face_name(e);
	else if (local_name == "font-face-src") font_face_src(e);
	else if (local_name == "font-face-uri") font_face_uri(e);
	else if (local_name == "foreignObject") foreignObject(e);
	else if (local_name == "g") g(e);
	else if (local_name == "glyph") glyph(e);
	else if (local_name == "glyphRef") glyphRef(e);
	else if (local_name == "hkern") hkern(e);
	else if (local_name == "image") image(e);
	else if (local_name == "line") line(e);
	else if (local_name == "linearGradient") linearGradient(e);
	else if (local_name == "marker") marker(e);
	else if (local_name == "mask") mask(e);
	else if (local_name == "metadata") metadata(e);
	else if (local_name == "missing-glyph") missing_glyph(e);
	else if (local_name == "mpath") mpath(e);
	else if (local_name == "path") path(e);
	else if (local_name == "pattern") pattern(e);
	else if (local_name == "polygon") polygon(e);
	else if (local_name == "polyline") polyline(e);
	else if (local_name == "radialGradient") radialGradient(e);
	else if (local_name == "rect") rect(e);
	else if (local_name == "script") script(e);
	else if (local_name == "set") set(e);
	else if (local_name == "stop") stop(e);
	else if (local_name == "style") style(e);
	else if (local_name == "svg") svg(e);
	else if (local_name == "switch") switch_(e);
	else if (local_name == "symbol") symbol(e);
	else if (local_name == "text") text(e);
	else if (local_name == "textPath") textPath(e);
	else if (local_name == "title") title(e);
	else if (local_name == "tref") tref(e);
	else if (local_name == "tspan") tspan(e);
	else if (local_name == "use") use(e);
	else if (local_name == "view") view(e);
	else if (local_name == "vkern") vkern(e);
}
Exemplo n.º 10
0
void b2ContactSolver::SolveVelocityConstraints()
{
	for (int32 i = 0; i < m_count; ++i)
	{
		b2ContactVelocityConstraint* vc = m_velocityConstraints + i;

		int32 indexA = vc->indexA;
		int32 indexB = vc->indexB;
		float32 mA = vc->invMassA;
		float32 iA = vc->invIA;
		float32 mB = vc->invMassB;
		float32 iB = vc->invIB;
		int32 pointCount = vc->pointCount;

		b2Vec2 vA = m_velocities[indexA].v;
		float32 wA = m_velocities[indexA].w;
		b2Vec2 vB = m_velocities[indexB].v;
		float32 wB = m_velocities[indexB].w;

		b2Vec2 normal = vc->normal;
		b2Vec2 tangent = b2Cross(normal, 1.0f);
		float32 friction = vc->friction;

		b2Assert(pointCount == 1 || pointCount == 2);

		// Solve tangent constraints first because non-penetration is more important
		// than friction.
		for (int32 j = 0; j < pointCount; ++j)
		{
			b2VelocityConstraintPoint* vcp = vc->points + j;

			// Relative velocity at contact
			b2Vec2 dv = vB + b2Cross(wB, vcp->rB) - vA - b2Cross(wA, vcp->rA);

			// Compute tangent force
			float32 vt = b2Dot(dv, tangent);
			float32 lambda = vcp->tangentMass * (-vt);

			// b2Clamp the accumulated force
			float32 maxFriction = friction * vcp->normalImpulse;
			float32 newImpulse = b2Clamp(vcp->tangentImpulse + lambda, -maxFriction, maxFriction);
			lambda = newImpulse - vcp->tangentImpulse;
			vcp->tangentImpulse = newImpulse;

			// Apply contact impulse
			b2Vec2 P = lambda * tangent;

			vA -= mA * P;
			wA -= iA * b2Cross(vcp->rA, P);

			vB += mB * P;
			wB += iB * b2Cross(vcp->rB, P);
		}

		// Solve normal constraints
		if (vc->pointCount == 1)
		{
			b2VelocityConstraintPoint* vcp = vc->points + 0;

			// Relative velocity at contact
			b2Vec2 dv = vB + b2Cross(wB, vcp->rB) - vA - b2Cross(wA, vcp->rA);

			// Compute normal impulse
			float32 vn = b2Dot(dv, normal);
			float32 lambda = -vcp->normalMass * (vn - vcp->velocityBias);

			// b2Clamp the accumulated impulse
			float32 newImpulse = b2Max(vcp->normalImpulse + lambda, 0.0f);
			lambda = newImpulse - vcp->normalImpulse;
			vcp->normalImpulse = newImpulse;

			// Apply contact impulse
			b2Vec2 P = lambda * normal;
			vA -= mA * P;
			wA -= iA * b2Cross(vcp->rA, P);

			vB += mB * P;
			wB += iB * b2Cross(vcp->rB, P);
		}
		else
		{
			// Block solver developed in collaboration with Dirk Gregorius (back in 01/07 on Box2D_Lite).
			// Build the mini LCP for this contact patch
			//
			// vn = A * x + b, vn >= 0, , vn >= 0, x >= 0 and vn_i * x_i = 0 with i = 1..2
			//
			// A = J * W * JT and J = ( -n, -r1 x n, n, r2 x n )
			// b = vn0 - velocityBias
			//
			// The system is solved using the "Total enumeration method" (s. Murty). The complementary constraint vn_i * x_i
			// implies that we must have in any solution either vn_i = 0 or x_i = 0. So for the 2D contact problem the cases
			// vn1 = 0 and vn2 = 0, x1 = 0 and x2 = 0, x1 = 0 and vn2 = 0, x2 = 0 and vn1 = 0 need to be tested. The first valid
			// solution that satisfies the problem is chosen.
			// 
			// In order to account of the accumulated impulse 'a' (because of the iterative nature of the solver which only requires
			// that the accumulated impulse is clamped and not the incremental impulse) we change the impulse variable (x_i).
			//
			// Substitute:
			// 
			// x = a + d
			// 
			// a := old total impulse
			// x := new total impulse
			// d := incremental impulse 
			//
			// For the current iteration we extend the formula for the incremental impulse
			// to compute the new total impulse:
			//
			// vn = A * d + b
			//    = A * (x - a) + b
			//    = A * x + b - A * a
			//    = A * x + b'
			// b' = b - A * a;

			b2VelocityConstraintPoint* cp1 = vc->points + 0;
			b2VelocityConstraintPoint* cp2 = vc->points + 1;

			b2Vec2 a(cp1->normalImpulse, cp2->normalImpulse);
			b2Assert(a.x >= 0.0f && a.y >= 0.0f);

			// Relative velocity at contact
			b2Vec2 dv1 = vB + b2Cross(wB, cp1->rB) - vA - b2Cross(wA, cp1->rA);
			b2Vec2 dv2 = vB + b2Cross(wB, cp2->rB) - vA - b2Cross(wA, cp2->rA);

			// Compute normal velocity
			float32 vn1 = b2Dot(dv1, normal);
			float32 vn2 = b2Dot(dv2, normal);

			b2Vec2 b;
			b.x = vn1 - cp1->velocityBias;
			b.y = vn2 - cp2->velocityBias;

			// Compute b'
			b -= b2Mul(vc->K, a);

			const float32 k_errorTol = 1e-3f;
			B2_NOT_USED(k_errorTol);

			for (;;)
			{
				//
				// Case 1: vn = 0
				//
				// 0 = A * x + b'
				//
				// Solve for x:
				//
				// x = - inv(A) * b'
				//
				b2Vec2 x = - b2Mul(vc->normalMass, b);

				if (x.x >= 0.0f && x.y >= 0.0f)
				{
					// Get the incremental impulse
					b2Vec2 d = x - a;

					// Apply incremental impulse
					b2Vec2 P1 = d.x * normal;
					b2Vec2 P2 = d.y * normal;
					vA -= mA * (P1 + P2);
					wA -= iA * (b2Cross(cp1->rA, P1) + b2Cross(cp2->rA, P2));

					vB += mB * (P1 + P2);
					wB += iB * (b2Cross(cp1->rB, P1) + b2Cross(cp2->rB, P2));

					// Accumulate
					cp1->normalImpulse = x.x;
					cp2->normalImpulse = x.y;

#if B2_DEBUG_SOLVER == 1
					// Postconditions
					dv1 = vB + b2Cross(wB, cp1->rB) - vA - b2Cross(wA, cp1->rA);
					dv2 = vB + b2Cross(wB, cp2->rB) - vA - b2Cross(wA, cp2->rA);

					// Compute normal velocity
					vn1 = b2Dot(dv1, normal);
					vn2 = b2Dot(dv2, normal);

					b2Assert(b2Abs(vn1 - cp1->velocityBias) < k_errorTol);
					b2Assert(b2Abs(vn2 - cp2->velocityBias) < k_errorTol);
#endif
					break;
				}

				//
				// Case 2: vn1 = 0 and x2 = 0
				//
				//   0 = a11 * x1 + a12 * 0 + b1' 
				// vn2 = a21 * x1 + a22 * 0 + b2'
				//
				x.x = - cp1->normalMass * b.x;
				x.y = 0.0f;
				vn1 = 0.0f;
				vn2 = vc->K.ex.y * x.x + b.y;

				if (x.x >= 0.0f && vn2 >= 0.0f)
				{
					// Get the incremental impulse
					b2Vec2 d = x - a;

					// Apply incremental impulse
					b2Vec2 P1 = d.x * normal;
					b2Vec2 P2 = d.y * normal;
					vA -= mA * (P1 + P2);
					wA -= iA * (b2Cross(cp1->rA, P1) + b2Cross(cp2->rA, P2));

					vB += mB * (P1 + P2);
					wB += iB * (b2Cross(cp1->rB, P1) + b2Cross(cp2->rB, P2));

					// Accumulate
					cp1->normalImpulse = x.x;
					cp2->normalImpulse = x.y;

#if B2_DEBUG_SOLVER == 1
					// Postconditions
					dv1 = vB + b2Cross(wB, cp1->rB) - vA - b2Cross(wA, cp1->rA);

					// Compute normal velocity
					vn1 = b2Dot(dv1, normal);

					b2Assert(b2Abs(vn1 - cp1->velocityBias) < k_errorTol);
#endif
					break;
				}


				//
				// Case 3: vn2 = 0 and x1 = 0
				//
				// vn1 = a11 * 0 + a12 * x2 + b1' 
				//   0 = a21 * 0 + a22 * x2 + b2'
				//
				x.x = 0.0f;
				x.y = - cp2->normalMass * b.y;
				vn1 = vc->K.ey.x * x.y + b.x;
				vn2 = 0.0f;

				if (x.y >= 0.0f && vn1 >= 0.0f)
				{
					// Resubstitute for the incremental impulse
					b2Vec2 d = x - a;

					// Apply incremental impulse
					b2Vec2 P1 = d.x * normal;
					b2Vec2 P2 = d.y * normal;
					vA -= mA * (P1 + P2);
					wA -= iA * (b2Cross(cp1->rA, P1) + b2Cross(cp2->rA, P2));

					vB += mB * (P1 + P2);
					wB += iB * (b2Cross(cp1->rB, P1) + b2Cross(cp2->rB, P2));

					// Accumulate
					cp1->normalImpulse = x.x;
					cp2->normalImpulse = x.y;

#if B2_DEBUG_SOLVER == 1
					// Postconditions
					dv2 = vB + b2Cross(wB, cp2->rB) - vA - b2Cross(wA, cp2->rA);

					// Compute normal velocity
					vn2 = b2Dot(dv2, normal);

					b2Assert(b2Abs(vn2 - cp2->velocityBias) < k_errorTol);
#endif
					break;
				}

				//
				// Case 4: x1 = 0 and x2 = 0
				// 
				// vn1 = b1
				// vn2 = b2;
				x.x = 0.0f;
				x.y = 0.0f;
				vn1 = b.x;
				vn2 = b.y;

				if (vn1 >= 0.0f && vn2 >= 0.0f )
				{
					// Resubstitute for the incremental impulse
					b2Vec2 d = x - a;

					// Apply incremental impulse
					b2Vec2 P1 = d.x * normal;
					b2Vec2 P2 = d.y * normal;
					vA -= mA * (P1 + P2);
					wA -= iA * (b2Cross(cp1->rA, P1) + b2Cross(cp2->rA, P2));

					vB += mB * (P1 + P2);
					wB += iB * (b2Cross(cp1->rB, P1) + b2Cross(cp2->rB, P2));

					// Accumulate
					cp1->normalImpulse = x.x;
					cp2->normalImpulse = x.y;

					break;
				}

				// No solution, give up. This is hit sometimes, but it doesn't seem to matter.
				break;
			}
		}

		m_velocities[indexA].v = vA;
		m_velocities[indexA].w = wA;
		m_velocities[indexB].v = vB;
		m_velocities[indexB].w = wB;
	}
}
Exemplo n.º 11
0
int main(int argc, char *argv[])
{
    int res = 0;
    {
        Device::instance(); // initialize device
#ifndef i386
        QProcess::execute("eips -c");
        pTouch = new TouchScreen();
#endif
        lString16 exedir = LVExtractPath(LocalToUnicode(lString8(argv[0])));
        LVAppendPathDelimiter(exedir);
        lString16 datadir = exedir + L"data/";
        lString16 exefontpath = exedir + L"fonts";

        lString16Collection fontDirs;
        fontDirs.add(exefontpath);
#ifndef i386
        fontDirs.add(lString16(L"/usr/java/lib/fonts"));
        fontDirs.add(lString16(L"/mnt/us/fonts"));
#endif
        CRPropRef props = LVCreatePropsContainer();
        {
            LVStreamRef cfg = LVOpenFileStream(UnicodeToUtf8(datadir + L"cr3.ini").data(), LVOM_READ);
            if(!cfg.isNull()) props->loadFromStream(cfg.get());
        }

        lString16 lang = props->getStringDef(PROP_WINDOW_LANG, "");
        InitCREngineLog(props);
        CRLog::info("main()");

        if(!InitCREngine(argv[0], fontDirs)) {
            printf("Cannot init CREngine - exiting\n");
            return 2;
        }
#ifndef i386
        PrintString(1, 1, "crengine version: " + QString(CR_ENGINE_VERSION));
        PrintString(1, 2, QString("buid date: %1 %2").arg(__DATE__).arg(__TIME__));
        if (!Device::isTouch()) {
            QString message = "Please wait while application is loading...";
            int xpos = ((Device::getWidth()/12-1)-message.length())/2;
            int ypos = (Device::getHeight()/20-2)/2;
            PrintString(xpos, ypos, message);
        }
#endif

        // set row count
        int rc = props->getIntDef(PROP_WINDOW_ROW_COUNT, 0);
        if(!rc) {
#ifndef i386
            props->setInt(PROP_WINDOW_ROW_COUNT, Device::getModel() != Device::KDX ? 10 : 16);
#else
            props->setInt(PROP_WINDOW_ROW_COUNT, 10);
#endif
            LVStreamRef cfg = LVOpenFileStream(UnicodeToUtf8(datadir + L"cr3.ini").data(), LVOM_WRITE);
            props->saveToStream(cfg.get());
        }

        QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8"));
        MyApplication a(argc, argv);
        pMyApp = &a;
        // set app stylesheet
#ifndef i386
        QString style = (Device::getModel() != Device::KDX ? "stylesheet_k3.qss" : "stylesheet_dx.qss");
        if (Device::getModel() == Device::KPW) style = "stylesheet_pw.qss";
        QFile qss(QDir::toNativeSeparators(cr2qt(datadir)) + style);
        // set up full update interval for the graphics driver
        QKindleFb *pscreen = static_cast<QKindleFb*>(QScreen::instance());
        pscreen->setFullUpdateEvery(props->getIntDef(PROP_DISPLAY_FULL_UPDATE_INTERVAL, 1));
#else
        QFile qss(QDir::toNativeSeparators(cr2qt(datadir)) + "stylesheet_k3.qss");
#endif
        qss.open(QFile::ReadOnly);
        if(qss.error() == QFile::NoError) {
            a.setStyleSheet(qss.readAll());
            qss.close();
        }
        QString translations = cr2qt(datadir) + "i18n";
        QTranslator myappTranslator;
        if(!lang.empty() && lang.compare(L"English")) {
            if(myappTranslator.load(cr2qt(lang), translations))
                QApplication::installTranslator(&myappTranslator);
            else
                qDebug("Can`t load translation file %s from dir %s", UnicodeToUtf8(lang).c_str(), UnicodeToUtf8(qt2cr(translations)).c_str());
        }

        (void) signal(SIGUSR1, sigCatcher);

        MainWindow mainWin;
        a.setMainWindow(&mainWin);
        mainWin.showFullScreen();
        mainWin.doStartupActions();
        res = a.exec();
    }
    ShutdownCREngine();
    return res;
}
Exemplo n.º 12
0
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

//![2]
    QLoggingCategory::setFilterRules(QStringLiteral("qt.driver.usb.debug=true"));
//![2]

//![22]

// ...
oldCategoryFilter = QLoggingCategory::installFilter(myCategoryFilter);
//![22]

//![3]
    qSetMessagePattern("%{category} %{message}");
//![3]

//![4]
    // usbEntries() will only be called if QT_DRIVER_USB category is enabled
    qCDebug(QT_DRIVER_USB) << "devices: " << usbEntries();
//![4]

    {
//![10]
    QLoggingCategory category("qt.driver.usb");
    qCDebug(category) << "a debug message";
//![10]
    }

    {
//![11]
    QLoggingCategory category("qt.driver.usb");
    qCWarning(category) << "a warning message";
//![11]
    }

    {
//![12]
    QLoggingCategory category("qt.driver.usb");
    qCCritical(category) << "a critical message";
//![12]
    }

    {
//![13]
    QLoggingCategory category("qt.driver.usb");
    qCDebug(category, "a debug message logged into category %s", category.categoryName());
//![13]
    }

    {
//![14]
    QLoggingCategory category("qt.driver.usb");
    qCWarning(category, "a warning message logged into category %s", category.categoryName());
//![14]
    }

    {
//![15]
    QLoggingCategory category("qt.driver.usb");
    qCCritical(category, "a critical message logged into category %s", category.categoryName());
//![15]
    }

    return 0;
}
Exemplo n.º 13
0
/* Match image a to image b, returning the nearest neighbor field mapping a => b coords, stored in an RGB 24-bit image as (by<<12)|bx. */
void PatchMatch::patchmatch(cv::Mat &image, cv::Mat &b, BITMAP *ann, BITMAP &annd) {
  /* Initialize with random nearest neighbor field (NNF). */
		cv::Mat a(image.size(), CV_64F);
		image.copyTo(a);
  int aew = a.cols - patch_w+1, aeh = a.rows - patch_w + 1;       /* Effective width and height (possible upper left corners of patches). */
  int bew = b.cols - patch_w+1, beh = b.rows - patch_w + 1;

  for (int ay = 0; ay < aeh; ay++) {
    for (int ax = 0; ax < aew; ax++) {
		int bx, by;
		//if((*ann)[ay][ax] == 0){
		//	  bx = rand() % bew;
		//	  by = rand() % beh;
		//	  (*ann)[ay][ax] = XY_TO_INT(bx, by);
		//}
		//else{
		//	bx = INT_TO_X((*ann)[ay][ax]);
		//	by = INT_TO_Y((*ann)[ay][ax]);
		//}
		bx = rand() % bew;
		by = rand() % beh;
		(*ann)[ay][ax] = XY_TO_INT(bx, by);
		
      annd[ay][ax] = dist(a, b, ax, ay, bx, by);
    }
  }
    int as;
    std::ofstream o_file;
    o_file.open("1.txt");
  for (int iter = 0; iter < pm_iters; iter++) {
    /* In each iteration, improve the NNF, by looping in scanline or reverse-scanline order. */
    int ystart = 0, yend = aeh, ychange = 1;
    int xstart = 0, xend = aew, xchange = 1;
    if (iter % 2 == 1) {
      xstart = xend-1; xend = -1; xchange = -1;
      ystart = yend-1; yend = -1; ychange = -1;
    }

	
//	if(iter == 2)
		as = 0;
    for (int ay = ystart; ay != yend; ay += ychange) {
      for (int ax = xstart; ax != xend; ax += xchange) { 
        /* Current (best) guess. */
		  //if(ax == 366 && ay == 367)
			 // as++;
		//  int sdsd = targetMask[ay * a.cols + ax];
		//if(ax == 352 && ay == 73){
		//	as++;
		//}
        int v = (*ann)[ay][ax];
        int xbest = INT_TO_X(v), ybest = INT_TO_Y(v);
        int dbest = annd[ay][ax];

        /* Propagation: Improve current guess by trying instead correspondences from left and above (below and right on odd iterations). */
		int targetCount = 0;
		for(int i = 0; i < patch_w; i++){
			for(int j = 0; j < patch_w; j++){
				if(targetMask[(ay + i) * a.cols + ax + j] > 0)
					targetCount++;
			}
		}
		if(targetCount > patch_w){
			int vp = (*ann)[ay][ax - xchange];
			int xp = INT_TO_X(vp) + xchange, yp = INT_TO_Y(vp);
			if ((unsigned) xp < (unsigned) bew) {
				xbest = xp;
				ybest = yp;
				(*ann)[ay][ax] = XY_TO_INT(xbest, ybest);
				annd[ay][ax] = annd[ay][ax - xchange];
				continue;
			}
			//else{
			//	vp = (*ann)[ay - ychange][ax];
			//	xp = INT_TO_X(vp), yp = INT_TO_Y(vp) + ychange;
			//	if ((unsigned) yp < (unsigned) beh) {
			//		xbest = xp;
			//		ybest = yp;
			//		(*ann)[ay][ax] = XY_TO_INT(xbest, ybest);
			//		annd[ay][ax] = annd[ay - ychange][ax];
			//		continue;
			//	}
			//}
			if((unsigned) (ay - ychange) < (unsigned) aeh){
				int vp = (*ann)[ay - ychange][ax];
			    int xp = INT_TO_X(vp), yp = INT_TO_Y(vp) + ychange;
			    if ((unsigned) yp < (unsigned) beh) {
			 		improve_guess(a, b, ax, ay, xbest, ybest, dbest, xp, yp);
			    }
			}
		}
		else{
			if ((unsigned) (ax - xchange) < (unsigned) aew) {
			  int vp = (*ann)[ay][ax - xchange];
			  int xp = INT_TO_X(vp) + xchange, yp = INT_TO_Y(vp);
			  if ((unsigned) xp < (unsigned) bew) {
				improve_guess(a, b, ax, ay, xbest, ybest, dbest, xp, yp);
			  }
			}

			if ((unsigned) (ay - ychange) < (unsigned) aeh) {
			  int vp = (*ann)[ay - ychange][ax];
			  int xp = INT_TO_X(vp), yp = INT_TO_Y(vp) + ychange;
			  if ((unsigned) yp < (unsigned) beh) {
				improve_guess(a, b, ax, ay, xbest, ybest, dbest, xp, yp);
			  }
			}
		}

        /* Random search: Improve current guess by searching in boxes of exponentially decreasing size around the current best guess. */
        int rs_start = rs_max;
        if (rs_start > MAX(b.cols, b.rows)) { rs_start = MAX(b.cols, b.rows); }
        for (int mag = rs_start; mag >= 1; mag /= 2) {
            /* Sampling window */
            int xmin = MAX(xbest-mag, 0), xmax = MIN(xbest+mag+1,bew);
            int ymin = MAX(ybest-mag, 0), ymax = MIN(ybest+mag+1,beh);
            int xp = xmin+rand()%(xmax-xmin);
            int yp = ymin+rand()%(ymax-ymin);

		    int targetCount = 0;
			for(int i = 0; i < patch_w; i++){
				for(int j = 0; j < patch_w; j++){
					if(targetMask[(yp + i) * a.cols + xp + j] > 0){
						targetCount++;
						break;
					}
				}
				if(targetCount > 0)
					break;
			}
			if(targetCount > 0){
				mag *= 2;
				continue;
			}
            improve_guess(a, b, ax, ay, xbest, ybest, dbest, xp, yp);
        }

        (*ann)[ay][ax] = XY_TO_INT(xbest, ybest);
        annd[ay][ax] = dbest;
		//a.at<cv::Vec3b>(ay, ax) = b.at<cv::Vec3b>(ybest, xbest);
		
		//for (int dy = 0; dy < patch_w; dy++) {
		//	for (int dx = 0; dx < patch_w; dx++) {
		//		a.at<cv::Vec3b>(ay + dy, ax + dx) = b.at<cv::Vec3b>(ybest + dy, xbest + dx);
		//	}
	 //   }
		if(ay != ybest || ax != xbest)
			as++;

		if(ax == 352 && ay == 73){
			as++;
		}
	//	for(int i = 0; i < cvImage.rows - 7 + 1; i++){
	//	for(int j = 0; j < cvImage.cols - 7 + 1; j++){
	//		int v = (*ann)[i][j];
	//		int x = INT_TO_X(v);
	//		int y = INT_TO_Y(v);
	//		anni.at<cv::Vec3b>(i, j).val[0] = (0+ x) % 256;
	//		anni.at<cv::Vec3b>(i, j).val[1] = (0 + y) % 256;
	//		anni.at<cv::Vec3b>(i, j).val[2] = 0;

	//		if(annd[i][j] > 0){
	//		anndi.at<cv::Vec3b>(i, j).val[0] = annd[i][j] % 256;
	//		}
	//		else 
	//			anndi.at<cv::Vec3b>(i, j).val[0] = 0;
	//		anndi.at<cv::Vec3b>(i, j).val[1] = 0;
	//		anndi.at<cv::Vec3b>(i, j).val[2] = 0;
	//	}
	//}
	//cv::imshow("r", anni);
	//cv::imshow("rd", anndi);
      }
    }
	//std::string s[] = {"0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"};
	//cv::imshow(s[iter], a);

	o_file<<as<<std::endl;
	std::cout<<as<<std::endl;
  }
  o_file.close();

  a.copyTo(image);
}
Exemplo n.º 14
0
int main( int argc_, char **argv_ )
{
    meerkat::mk_argument_manager a("Force-directed edge bundling calculator",
                                   "Usage: fdeb [options]");
    a.add_help();
    a.add_argument_entry( "nodes", MK_VALUE, "--nodes", "-n",
                          "File containing node positions", "", MK_REQUIRED);
    a.add_argument_entry( "edges", MK_VALUE, "--edges", "-e",
                          "File containing edges", "", MK_REQUIRED);
    a.add_argument_entry( "json", MK_VALUE, "--json", "-json",
                          "Prints result in a JSON file [unset]", "", MK_OPTIONAL);
    a.add_argument_entry( "K", MK_VALUE, "--K", "-K",
                          "Edge stiffness [0.1]", "0.1", MK_OPTIONAL);
    a.add_argument_entry( "S", MK_VALUE, "--S", "-S",
                          "Initial value of S [0.4]", "0.4", MK_OPTIONAL);
    a.add_argument_entry( "I", MK_VALUE, "--I", "-i",
                          "Initial number of iterations [90]", "90", MK_OPTIONAL);
    a.add_argument_entry( "compat", MK_VALUE, "--compat", "-c",
                          "Compatibility threshold [0.6]", "0.6", MK_OPTIONAL);
    a.add_argument_entry( "cycles", MK_VALUE, "--cycles", "-C",
                          "Max number of cycles [5]", "5", MK_OPTIONAL);
    a.add_argument_entry( "sigma", MK_VALUE, "--sigma", "-s",
                          "Smoothing width [3]", "3", MK_OPTIONAL);
    a.add_argument_entry( "edge weight", MK_VALUE, "--edge-weight", "-ew",
                          "Edge weight threshold for edge filtering [unset]."
                          "Edges with a weight below the given value are dropped",
                          "-1.0", MK_OPTIONAL);
    a.add_argument_entry( "edge percentage", MK_VALUE, "--edge-percentage", "-ep",
                          "Edge percentage for edge filtering [unset]."
                          "The given fraction of edges among the strongest ones are kept",
                          "-1.0", MK_OPTIONAL);
    a.add_argument_entry( "epsilon", MK_VALUE, "--epsilon", "-E",
                          "Lowest interaction distance [1e-4]", "0.0001", MK_OPTIONAL);
    a.add_argument_entry( "gravitation center x", MK_VALUE, "--gravitation-center-x", "-gcx",
                          "Gravitation center x coordinate [0.0]. If set, gravitation is turned on",
                          "0.0", MK_OPTIONAL);
    a.add_argument_entry( "gravitation center y", MK_VALUE, "--gravitation-center-y", "-gcy",
                          "Gravitation center y coordinate [0.0]. If set, gravitation is turned on",
                          "0.0", MK_OPTIONAL);
    a.add_argument_entry( "gravitation exponent", MK_VALUE, "--gravitation-exponent", "-ge",
                          "Gravitation exponent [-2.0]. If set, gravitation is turned on",
                          "1.0", MK_OPTIONAL);
    a.add_argument_entry( "visualization", MK_FLAG, "--visualize", "-v",
                          "Enables real-time visualization [off]", "0", MK_OPTIONAL);
    a.add_argument_entry( "transparency", MK_VALUE, "--transparency", "-t",
                          "Transparency of edges", "0.3", MK_OPTIONAL);
    a.read_arguments(argc_, argv_);
    a.show_settings();

    // set params and read graph
    gGraph.set_algorithm_params( a.get_double_argument("K"),
                                 a.get_int_argument("cycles"),
                                 a.get_int_argument("I"),
                                 a.get_double_argument("compat"),
                                 a.get_double_argument("sigma"));
    gGraph.set_network_params( a.get_double_argument("edge weight"),
                               a.get_double_argument("edge percentage") );
    gGraph.set_physics_params( a.get_double_argument("S"),
                               a.get_double_argument("epsilon"),
                               meerkat::mk_vector2(a.get_double_argument("gravitation center x"),
                                                   a.get_double_argument("gravitation center y")),
                               a.get_double_argument("gravitation exponent") );
    if( a.is_set("gravitation center x") ||
            a.is_set("gravitation center y") ||
            a.is_set("gravitation exponent") )
        gGraph.enable_gravitation();

    // Read graph
    gGraph.read(a.get_string_argument("nodes"),
                a.get_string_argument("edges"));

    // Get output name
    if( a.is_set("json") )
        gJson = a.get_string_argument("json");

    // If visualization is enabled
    if( a.is_set("visualization") )
    {
        // Set graphical parameters
        gGraph.set_graphics_params( a.get_double_argument("transparency") );

        // Get bounding box
        meerkat::mk_vector2 bottomLeft, topRight;
        gGraph.get_bounding_box(bottomLeft, topRight, 20.0);
        double gWidth = topRight.x() - bottomLeft.x();
        double gHeight = topRight.y() - bottomLeft.y();

        // Init GLUT
        int wWidth = DEFAULT_SIZE, wHeight = DEFAULT_SIZE;
        if( gWidth > gHeight )
            wHeight = int(wWidth * gHeight/gWidth);
        else
            wWidth = int(wHeight * gWidth/gHeight);
        glutInit( &argc_, argv_ );
        glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );
        glutInitWindowSize( wWidth, wHeight );
        glutInitWindowPosition( 10, 100 );
        glutCreateWindow( "fdeb" );
        init(bottomLeft, topRight);

        // Increase cycle index and enter main loop
        glutDisplayFunc( display );
        glutKeyboardFunc( keyboard );
        glutTimerFunc( 10, timer, 1 );
        glutMainLoop();
    }
    // Otherwise, just perform edge bundling
    else
    {
        do
        {
            while( gGraph.iterate() > 0 );
            gGraph.add_subvisions();
        } while( gGraph.update_cycle() > 0 );
        gGraph.smooth();
        if( gJson != "" )
            gGraph.print_json(gJson);
    }

    return 0;
}
Exemplo n.º 15
0
int main()
{
  namespace stdx = std::experimental;
  namespace mem_usage_able = std::experimental;
  {
    int i = 0;
    std::experimental::Array<int> a (10);
    std::vector<int> v (10);
    std::vector<std::pair<int, int>> vp;
    std::pair<std::vector<int>, std::vector<int>> pv;
    boost::optional<int> o;
    boost::optional<std::vector<int>> ov;
    std::vector<boost::optional<int>> vo;
    std::unique_ptr<int> up;
    boost::optional<std::tuple<int>> ot;

    static_assert(stdx::meta::is_valid<decltype(mem_usage_able::mem_usage(i))>, "");
    std::cout << mem_usage_able::mem_usage(i) << "\n";
    std::cout << mem_usage_able::mem_usage(a) << "\n";
    std::cout << mem_usage_able::mem_usage(v) << "\n";
    std::cout << mem_usage_able::mem_usage(o) << "\n";

#if 0
    // compile fails as expected
    decltype(mem_usage_able::mem_usage(up)) xx;
#endif

    std::cout << mem_usage_able::mem_usage(vp) << "\n";
    std::cout << mem_usage_able::mem_usage(pv) << "\n";
    std::cout << mem_usage_able::mem_usage(ov) << "\n";
    std::cout << mem_usage_able::mem_usage(vo) << "\n";
  }
  int i = 0;
  std::experimental::Array<int> a (10);
  std::vector<int> v (10);
  std::vector<std::pair<int, int>> vp;
  boost::optional<int> o;
  boost::optional<std::vector<int>> ov;

  std::cout << mem_usage_able::mem_usage(i) << "\n";
  std::cout << mem_usage_able::mem_usage(a) << "\n";
  std::cout << mem_usage_able::mem_usage(v) << "\n";
  std::cout << mem_usage_able::mem_usage(o) << "\n";
  std::cout << mem_usage_able::mem_usage(vp) << "\n";
  std::cout << mem_usage_able::mem_usage(ov) << "\n";

  {
    int* t;
    std::cout << "int* " << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    trace = true;
    int* t=new int;
    std::cout << "int* " << mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }

#if __cplusplus > 201402L
  {
    std::tuple<int, int> t;
    std::cout <<"std::tuple<int, int> " << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    std::tuple<std::vector<int>, int> t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    trace = false;
    using T = std::pair<int, int>;
    static_assert(! std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }
  {
    trace = false;
    typedef Point2D T;
    T t;
    std::cout << "X=== " << mem_usage_able::mem_usage(t) << "\n";
    trace = false;

  }
#if 0
  {
    // COMPILE FAIL AS EXPECTED: mem_usage for pt is been defined
    // However we don't want this behavior.
    trace = true;
    using T = std::pair<short, Point2D>;
    static_assert(! std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << "std::pair<short, std::pair<X, X>>=== " << mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }
#endif
  {
    // fixme : why this works? mem_usage for pt is been defined
    trace = false;
    using T = std::pair<short, std::pair<Point2D, X>>;
    //using T = std::pair<short, Point2D>;
    static_assert(stdx::product_type::size<std::pair<short, std::pair<X, long>>>::value == 2, "");
    static_assert(! std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << "std::pair<short, std::pair<X, X>>=== " << mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }
  {
    trace = false;
    using T = std::array<int, 3>;
    static_assert(std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
    trace = false;

  }
  {
    typedef int T[3];
    static_assert(std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << "int[3] " << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    typedef std::pair<int,int> T[3];
    static_assert(!std::is_trivial<T>::value, "");
    static_assert(stdx::is_product_type<T>::value, "");
    T t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    std::vector<std::tuple<int, int>> t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
  }
  {
    trace = false;
    std::array<std::pair<int, short>,2> t;
    std::cout << "std::array<std::pair<int, short>,2> "<< mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }
  {
    std::pair<std::array<int,2>, std::array<int,2> > t;
    std::cout << mem_usage_able::mem_usage(t) << "\n";
  }
#if 0
  {
    trace = true;
    Point2D* t=new Point2D;
    std::cout << "Point2D* " << mem_usage_able::mem_usage(t) << "\n";
    trace = false;
  }
#endif

#endif
  return ::boost::report_errors();
}
Exemplo n.º 16
0
unsigned OnAnotherThread( unsigned(*a)( unsigned, void *, unsigned, void * ), unsigned b, void *c, unsigned d, void *e )
{
    return( a( b, c, d, e ) );
}
Exemplo n.º 17
0
int main( int argc, char **argv )
{
    QGuiApplication a( argc, argv );
    return a.exec();
}
Exemplo n.º 18
0
int main(int argc, char **args)
{
  PetscErrorCode  ierr;
  PetscFunctionBegin;
  ierr = DCellInit(); CHKERRQ(ierr);

  int d1 = 64;
  Coor dh = {1./(d1-1), 1./(d1-1), 1./(d1-1)};

  PetscReal radius = 0.5;
  LevelSet ls;
  ierr = LevelSetInitializeToStar2D( dh, (Coor){0,0,0}, radius, 0.1, 7, &ls); CHKERRQ(ierr);
  ierr = GridWrite(ls->phi,0); CHKERRQ(ierr);
  ierr = LevelSetWriteIrregularNodeList(ls->irregularNodes,0); CHKERRQ(ierr);
  /*
  ierr = LevelSetInitializeToCircle( dh, (Coor){0,0,0}, radius, &ls); CHKERRQ(ierr);
  ierr = GridWrite(ls->phi,0); CHKERRQ(ierr);
  ierr = LevelSetWriteIrregularNodeList(ls->irregularNodes,0); CHKERRQ(ierr);
  */
  printf("len: %d\n",ArrayLength(ls->irregularNodes));
  printf("sizeof: %ld\n", sizeof(IrregularNode) );

  IrregularNode n;
  unsigned long p = &n.x;
  a(x);
  a(y);
  a(z);
  printf("\nshift\n");
  a(shift.x);
  a(shift.y);
  a(shift.z);
  printf("\nox\n");
  a(ox);
  a(oy);
  a(oz);
  printf("\n");
  a(nx);
  a(ny);
  a(nz);
  a(sx);
  a(sy);
  a(sz);
  a(rx);
  a(ry);
  a(rz);

  printf("\n");
  a(op.x);
  a(op.y);
  a(op.z);

  IrregularNode *N;
  ierr = ArrayGet(ls->irregularNodes,0,&N); CHKERRQ(ierr);
  printf("[%f, %f, %f] \n",N->ox,N->oy,N->oz);
  printf("[%f, %f, %f] \n",N->nx,N->ny,N->nz);
  printf("[%d, %d, %d] \n",N->x,N->y,N->z);
  printf("[%f, %f, %f] \n",N->op.x,N->op.y,N->op.z);

  double *data = ArrayGetData(ls->irregularNodes);

  for (int i = 0; i < 1e0; ++i) {
    printf("%f,",data[i]);
  }

  ierr = LevelSetDestroy(ls); CHKERRQ(ierr);
  ierr = DCellFinalize(); CHKERRQ(ierr);
  PetscFunctionReturn(0);
}
Exemplo n.º 19
0
int main(int argc, char *argv[])
{
	QCoreApplication a(argc, argv);
	IO::IODevicePtr src_device = nullptr;

	if (argc == param_count)
	{
		uint64_t start_offset = 0;
		std::string offset_txt(argv[offset_param]);
		if (offset_txt.compare(offset_str) == 0)
		{
			start_offset = boost::lexical_cast<uint64_t>(argv[offset_value]);
			qInfo() << "offset : " << start_offset <<"(sectors)";
		}


		std::string disk_file_string(argv[disk_file_param]);
		if (disk_file_string.compare(d_str) == 0)
		{
			auto drive_number = boost::lexical_cast<uint32_t>(argv[source_value]);

			auto drive_list = IO::ReadPhysicalDrives();
			auto physical_drive = drive_list.find_by_number(drive_number);
			start_offset *= physical_drive->getBytesPerSector();
			if (physical_drive)
			{
				qInfo() << "You selected";
				qInfo() << "Number : " << drive_number;
				qInfo() << "Name :" << physical_drive->getDriveName().c_str();
				qInfo() << "Serial number : " << physical_drive->getSerialNumber().c_str();
				qInfo() << "Size : " << physical_drive->getSize() << "(bytes)";
			}
			src_device = std::make_shared<IO::DiskDevice>(physical_drive);
		}
		else if (disk_file_string.compare(f_str) == 0)
		{
			std::string src_path = argv[source_value];
			src_device = IO::makeFilePtr(IO::path_string(src_path.begin(), src_path.end()));
			start_offset *= default_sector_size;
		}

		if (!src_device->Open(IO::OpenMode::OpenRead))
		{
			qInfo() << "Error open source device.";
			return -1;
		}

		std::string targer_path = argv[target_value];
		IO::path_string target_folder(targer_path.begin(), targer_path.end());

		if (!src_device)
			return -1;

		//////////////////////////////////////////////////////////////////////////
		QList<JsonFileStruct> listFileStruct;


		QFile file("video.json");
		if (!file.open(QIODevice::ReadOnly))
		{
			qInfo() << "Error to open file. \"" << file.fileName() << "\"";
			return -1;
		}

		auto json_str = file.readAll();
		ReadJsonFIle(json_str, listFileStruct);
		if ( listFileStruct.empty())
		{
			qInfo() << "Error to read" << file.fileName() << "file. Wrong syntax.";
			return -1;
		}

		IO::HeaderBase::Ptr headerBase = std::make_shared<IO::HeaderBase>();
		for (auto theFileStruct : listFileStruct)
			headerBase->addFileFormat(toFileStruct(theFileStruct));

		IO::RawFactoryManager factory_manager;
		initFactoryMananger(factory_manager);

		IO::SignatureFinder signatureFinder(src_device, headerBase);

		//uint64_t start_offset = 0x0;
		uint64_t header_offset = 0;
		uint32_t counter = 0;
		while (start_offset < src_device->Size())
		{
			auto file_struct = signatureFinder.findHeader(start_offset, header_offset);
			if (!file_struct)
			{
				qInfo() << endl << endl << endl << "No more signatures found. Press any key to exit.";
				break;
			}
			qInfo() << "Found signature for [" << file_struct->getName().c_str() << "] file."; 
			qInfo() << "Offset : " << header_offset << "(bytes)";

			start_offset = header_offset;

 			auto raw_factory = factory_manager.Lookup(file_struct->getName());
			IO::RawAlgorithm * raw_algorithm = nullptr;
			if (!raw_factory)
			{
				IO::StandartRaw * standard_raw = new IO::StandartRaw(src_device);
				standard_raw->setMaxFileSize(file_struct->getMaxFileSize());
				standard_raw->setFooter(file_struct->getFooter(), file_struct->getFooterTailEndSize());
				standard_raw->setFooterOffsetSearchBlock(4, 4096);

				raw_algorithm = standard_raw;
				
			}
			else
			{
				raw_algorithm = raw_factory->createRawAlgorithm(src_device);
			}
				
				if (raw_algorithm->Specify(header_offset))
				{
					auto target_file = IO::offsetToPath(target_folder, header_offset, file_struct->getExtension(), 512);
					auto dst_file = IO::makeFilePtr(target_file);
					if (dst_file->Open(IO::OpenMode::Create))
					{
						auto target_size = raw_algorithm->SaveRawFile(*dst_file, header_offset);
						
						if ( target_size == 0)
						{
							qInfo() << "Error to save file. Exit." ;
							//break;

						}
						auto dst_size = dst_file->Size();
						dst_file->Close();
						qInfo() << "Successfully saved " << target_size << "(bytes)" << endl << endl;

						uint64_t jump_size = default_sector_size;

						if ( raw_algorithm->Verify(target_file) )
						{
							target_size /= default_sector_size;
							target_size *= default_sector_size;
							//////////////////////////////////////////////////////////////////////////
							jump_size = target_size;
						}
						else
						{
							// remove file
							IO::path_string new_fileName = target_file + L".bad_file";
							boost::filesystem::rename(target_file, new_fileName);
							//{
							//	qInfo() << "File" << target_file.c_str() << "was removed." << endl;
							//}
							//else
							//	qInfo() << "File" << target_file.c_str() << "Error to delete." << endl;


						}
						//if (jump_size == 0)
							jump_size = default_sector_size;
						start_offset = header_offset + jump_size;

					}
					else
					{
						qInfo() << "Error to create target file." << QString::fromStdWString(target_file);
						qInfo() << "Exit.";
						break;
					}
					
							

				}
				else
				{
					qInfo() << "Not specified for " << QString::fromStdString(file_struct->getName()) << "continue search for other signatures."<<endl;
					start_offset += default_sector_size;
				}
				if ( raw_algorithm)
					delete raw_algorithm;

				

			}



		


	}
	else
		qInfo() << "Wrong params";
	return a.exec();
}
Exemplo n.º 20
0
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    auto keys = QStyleFactory::keys();
    for (auto s : keys)
    {
        qDebug(s.toStdString().c_str());
    }

    QString ss = load_stylesheet(":/Stylesheets/common.qss");

#ifdef _6IT_UI_MOBILE
    ss.append(load_stylesheet(":/Stylesheets/common_mobile.qss"));
#else
    ss.append(load_stylesheet(":/Stylesheets/common_desktop.qss"));
#endif

#ifdef _6IT_QT_WINRT_DESKTOP
    ss.append(load_stylesheet(":/Stylesheets/winrt_desktop.qss"));
#elif defined(_6IT_QT_WINRT_PHONE)
    a.setStyle(QStyleFactory::create("Fusion"));
    ss.append(load_stylesheet(":/Stylesheets/winrt_phone.qss"));
#elif defined(_6IT_QT_WINRT_DESKTOP)
    ss.append(load_stylesheet(":/Stylesheets/windows_desktop.qss"));
#elif defined(_6IT_QT_IOS)
    ss.append(load_stylesheet(":/Stylesheets/ios.qss"));
#elif defined(_6IT_QT_ANDROID)
    a.setStyle(QStyleFactory::create("Fusion"));
    ss.append(load_stylesheet(":/Stylesheets/android.qss"));
#elif defined(_6IT_QT_LINUX_DESKTOP)
    ss.append(load_stylesheet(":/Stylesheets/linux_desktop.qss"));
#endif

    a.setStyleSheet(ss);

    QThread thread;
    auto pworker = new RZQtSubCWorker();
    auto &worker = *pworker;
    worker.moveToThread(&thread);
    thread.start();

    FileListWindow fileListWindow;
    ViewSourceWindow editorWindow;
    RunWindow runWindow;
    CompileWindow compileWindow(worker);
    fileListWindow.show();

    QObject::connect(&fileListWindow, SIGNAL(sourceSelected(QString)), &editorWindow, SLOT(show()));
    QObject::connect(&fileListWindow, SIGNAL(sourceSelected(QString)), &editorWindow, SLOT(loadFile(QString)));
    QObject::connect(&fileListWindow, SIGNAL(sourceSelected(QString)), &fileListWindow, SLOT(hide()));

    QObject::connect(&editorWindow, SIGNAL(navigatedBack()), &fileListWindow, SLOT(show()));
    QObject::connect(&editorWindow, SIGNAL(navigatedBack()), &editorWindow, SLOT(hide()));

    QObject::connect(&editorWindow, SIGNAL(runCode(QString const &)), &editorWindow, SLOT(hide()));
    QObject::connect(&editorWindow, SIGNAL(runCode(QString const &)), &compileWindow, SLOT(show()));
    QObject::connect(&editorWindow, SIGNAL(runCode(QString const &)), &compileWindow, SLOT(clear()));
    QObject::connect(&editorWindow, SIGNAL(runCode(QString const &)), &worker, SLOT(setSource(QString const &)));

    QObject::connect(&compileWindow, SIGNAL(navigatedBack()), &editorWindow, SLOT(show()));
    QObject::connect(&compileWindow, SIGNAL(navigatedBack()), &compileWindow, SLOT(hide()));
    QObject::connect(&worker, SIGNAL(compilationWillStart()), &compileWindow, SLOT(compileStarted()));
    QObject::connect(&worker, SIGNAL(compilationDidFinish()), &compileWindow, SLOT(compileFinished()));

    QObject::connect(&compileWindow, SIGNAL(runClicked()), &compileWindow, SLOT(hide()));
    QObject::connect(&compileWindow, SIGNAL(runClicked()), &runWindow, SLOT(show()));
    QObject::connect(&compileWindow, SIGNAL(runClicked()), &worker, SLOT(run()));

    QObject::connect(&runWindow, SIGNAL(navigatedBack()), &compileWindow, SLOT(show()));
    QObject::connect(&runWindow, SIGNAL(navigatedBack()), &runWindow, SLOT(hide()));
    QObject::connect(&worker, SIGNAL(runWillStart()), &runWindow, SLOT(runStarted()));
    QObject::connect(&worker, SIGNAL(runDidFinish()), &runWindow, SLOT(runFinished()));

    QObject::connect(&worker, SIGNAL(sourceChanged()), &worker, SLOT(compile()));
    QObject::connect(&worker, SIGNAL(compilerConsoleOutput(QString const &, int)), &compileWindow, SLOT(printString(QString const &, int)));
    QObject::connect(&worker, SIGNAL(runConsoleOutput(QString const &, int)), &runWindow, SLOT(printString(QString const &, int)));

    return a.exec();
}
Exemplo n.º 21
0
 FBRectangle operator+(const FBRectangle& b)
 {
     FBRectangle a(*this);
     a += b;
     return a;
 }
Exemplo n.º 22
0
/* Allocates memory */
void factor_vm::primitive_resize_array() {
  data_root<array> a(ctx->pop(), this);
  check_tagged(a);
  cell capacity = unbox_array_size();
  ctx->push(tag<array>(reallot_array(a.untagged(), capacity)));
}
Exemplo n.º 23
0
int main ( int argc , char **argv )
{
	fprintf(stdout,"\n===== SIMPLE UI TOOLKIT =====\n\n");
	 const char *wrong_arg = 0;
	 char *output_model_file = 0;
	 char *xforms_text = 0;
	 char *input_xml_file = 0;
	 sXformsNode *head;
    struct qt_cb_data *cb_data = (struct qt_cb_data *)0;
	if(argc)
	{
		#define OY_PARSE_STRING_ARG( opt ) \
                        if( pos + 1 < argc && argv[pos][i+1] == 0 ) \
                        { opt = argv[pos+1]; \
                          if( opt == 0 && strcmp(argv[pos+1],"0") ) \
                            wrong_arg = "-" #opt; \
                          ++pos; \
                          i = 1000; \
                        } else if(argv[pos][i+1] == '=') \
                        { opt = &argv[pos][i+2]; \
                          if( opt == 0 && strcmp(&argv[pos][i+2],"0") ) \
                            wrong_arg = "-" #opt; \
                          i = 1000; \
                        } else wrong_arg = "-" #opt; \
                        
                        
  	if(argc != 1)
  	{
    		int pos = 1, i;
    		while(pos < argc)
    		{
      			switch(argv[pos][0])
      			{
			case '-':
			    for(i = 1; i < (int)strlen(argv[pos]); ++i)
			    switch (argv[pos][i])
			    {
			      case 'o': OY_PARSE_STRING_ARG( output_model_file ); break;
			      case 'i': OY_PARSE_STRING_ARG( input_xml_file ); break;
			      case 'v': break;//oy_debug += 1; break;
			      case 'h': /* only for compatibility with cmd line */ break;
			      case 'l': /* only for compatibility with cmd line */ break;
#if 0
			      case '-':
				        if(strcmp(&argv[pos][2],"verbose") == 0)
				        { 
						//oy_debug += 1; 
						i=100; 
						break;
				        }
				        STRING_ADD( t, &argv[pos][2] );
				        text = oyStrrchr_(t, '=');
				        /* get the key only */
				        if(text)
				          text[0] = 0;
				        oyStringListAddStaticString_( &other_args,&other_args_n,
				                                      t,
				                            oyAllocateFunc_,oyDeAllocateFunc_ );
				        if(text)
				        oyStringListAddStaticString_( &other_args,&other_args_n,
				                            oyStrrchr_(&argv[pos][2], '=') + 1,
				                            oyAllocateFunc_,oyDeAllocateFunc_ );
				        else {
				          if(argv[pos+1])
				          {
				            oyStringListAddStaticString_( &other_args,
				                                          &other_args_n,
				                                          argv[pos+1],
				                            oyAllocateFunc_,oyDeAllocateFunc_ );
				            ++pos;
				          } else wrong_arg = argv[pos];
				        }
				        if(t) oyDeAllocateFunc_( t );
				        t = 0;
				        i=100; 
					break;
#endif
			      case '?':
			      default:
				        fprintf(stderr, "%s -%c\n", ("Unknown argument"), argv[pos][i]);
				        usage(argc, argv);
				        exit (0);
				        break;
			    }
            		break;
        		default:
           		wrong_arg = argv[pos];
	      		}
			if( wrong_arg )
			{
				fprintf(stderr, "%s %s\n", ("wrong argument to option:"), wrong_arg);
				exit(1);
			}
	     		++pos;
    		}

  	}
  	}
	


fprintf(stdout,"INPUT FILE = %s\n",input_xml_file);

#if 0
  if(!input_xml_file)
  {
    size_t text_size = 0;
    text = oyReadStdinToMem_(&text_size, oyAllocateFunc_);

    if(text_size == 0)
    {
                        usage(argc, argv);
                        exit (0);
    }
  }

#endif

  
  if(input_xml_file)
  {
   xforms_text =  sReadFileToMem(input_xml_file);
   //fprintf(stdout,"output xml file is : %s \n\n",xforms_text);
  }
  head = ParseXformsToTree( xforms_text);
  //sPrintsXformsTree(head);


    cb_data = sKdeGenerateGladeFile(head);
    QApplication a(argc, argv);
    SimpleUiKde w;
    w.show();
    
    return a.exec();
  //print_user_data(cb_data);
  /*
  if( ! gtk_builder_add_from_file( builder, sGTK_UI_FILE, &error ) )
    {
        g_warning( "%s", error->message );
        g_free( error );
        return( 1 );
    }
    
     //Get main window pointer from UI 
    window = GTK_WIDGET( gtk_builder_get_object( builder, sGTK_GLADE_MAIN_WINDOW_NAME) );
    // = MakeDummy();
    gtk_builder_connect_signals( builder, cb_data );
    g_object_unref( G_OBJECT( builder ) );
    gtk_widget_show( window );
    gtk_main();
    */
    fprintf(stdout,"\n");
    return( 0 );
}
Exemplo n.º 24
0
int main( int argc, char ** argv )
{
  char * in_file = NULL;
  char * out_file = NULL;

  unsigned int max_it = 2000; // Max nr. of iterations
  bool print_input = false;
  bool verbose = false;
  int mode = MODE_PT;  // 1: PocketTopo Optimize
                 // 2: Optimize2
                 // 3: OptimizeBest
                 // 4: PocketTopo Optimize with optimize_axis
                 // 5: OptimizeBest with optimize_axis
                 // 6: Optimize M at fixed G 
                 // 7: Optimize iterative
  double delta = 0.5; // required delta for OptimizeBest
  double error;
  unsigned int iter = 0;

  int ac = 1;
  while ( ac < argc ) {
    if ( strncmp(argv[ac],"-i",2) == 0 ) {
      max_it = atoi( argv[ac+1]);
      if ( max_it < 200 ) max_it = 200;
      ac += 2;
#ifdef EXPERIMENTAL
    } else if ( strncmp(argv[ac],"-m", 2) == 0 ) {
      mode = atoi( argv[ac+1] );
      if ( mode < MODE_PT || mode >= MODE_MAX ) mode = MODE_PT;
      ac += 2;
    } else if ( strncmp(argv[ac],"-d", 2) == 0 ) {
      delta = atof( argv[ac+1] );
      if ( delta < 0.001 ) delta = 0.5;
      ac += 2;
#endif
    } else if ( strncmp(argv[ac],"-p", 2) == 0 ) {
      print_input = true;
      ac ++;
    } else if ( strncmp(argv[ac],"-v", 2) == 0 ) {
      verbose = true;
      ac ++;
    } else if ( strncmp(argv[ac],"-h", 2) == 0 ) {
      usage();
      ac ++;
    } else {
      break;
    }
  }

  if ( ac >= argc ) {
    usage();
    return 0;
  }
  in_file = argv[ac];
  ac ++;
  if ( argc > ac ) {
    out_file = argv[ac];
  }
  
  if ( verbose ) {
    fprintf(stderr, "Calibration data file \"%s\"\n", in_file );
    if ( out_file ) {
      fprintf(stderr, "Calibration coeff file \"%s\"\n", out_file );
    }
    fprintf(stderr, "Max nr. iterations %d \n", max_it );
    #ifdef EXPERIMENTAL
      fprintf(stderr, "Optimization mode: nr. %d\n", mode );
    #endif
  }

  FILE * fp = fopen( in_file, "r" );
  if ( fp == NULL ) {
    fprintf(stderr, "ERROR: cannot open input file \"%s\"\n", in_file);
    return 0;
  }

  Calibration calib;
  int16_t gx, gy, gz, mx, my, mz;
  int grp;
  int ignore;
  int cnt = 0;
  char line[256];
  if ( fgets(line, 256, fp) == NULL ) { // empty file
    fclose( fp );
    return false;
  }
  if ( line[0] == '0' && line[1] == 'x' ) { // calib-coeff format
    if ( verbose ) {
      fprintf(stderr, "Input file format: calib-coeff\n");
    }
    int gx0, gy0, gz0, mx0, my0, mz0;
    // skip coeffs;
    for (int k=1; k<6; ++k ) fgets(line, 256, fp);
    // skip one more line
    fgets(line, 256, fp);
    // printf("reading after: %s\n", line);
    while ( fgets(line, 255, fp ) ) {
      // fprintf(stderr, line );
      char rem[32];
      if ( line[0] == '#' ) continue;
      sscanf( line, "G: %d %d %d M: %d %d %d %s %d %d",
          &gx0, &gy0, &gz0, &mx0, &my0, &mz0, rem, &grp, &ignore);
      gx = (int16_t)( gx0  );
      gy = (int16_t)( gy0  );
      gz = (int16_t)( gz0  );
      mx = (int16_t)( mx0  );
      my = (int16_t)( my0  );
      mz = (int16_t)( mz0  );
      calib.AddValues( gx, gy, gz, mx, my, mz, cnt, grp, ignore );
      ++cnt;
      if ( verbose ) {
        fprintf(stderr, 
          "%d G: %d %d %d  M: %d %d %d  [%d]\n",
          cnt, gx, gy, gz, mx, my, mz, grp );
      }
    }
  } else {
    if ( verbose ) {
      fprintf(stderr, "Input file format: calib-data\n");
    }
    rewind( fp );
    unsigned int gx0, gy0, gz0, mx0, my0, mz0;
    while ( fgets(line, 255, fp ) ) {
      // fprintf(stderr, line );
      if ( line[0] == '#' ) continue;
      sscanf( line, "%x %x %x %x %x %x %d %d",
          &gx0, &gy0, &gz0, &mx0, &my0, &mz0, &grp, &ignore);
      gx = (int16_t)( gx0 & 0xffff );
      gy = (int16_t)( gy0 & 0xffff );
      gz = (int16_t)( gz0 & 0xffff );
      mx = (int16_t)( mx0 & 0xffff );
      my = (int16_t)( my0 & 0xffff );
      mz = (int16_t)( mz0 & 0xffff );
      calib.AddValues( gx, gy, gz, mx, my, mz, cnt, grp, ignore );
      ++cnt;
      if ( verbose ) {
        fprintf(stderr, 
          "%d G: %d %d %d  M: %d %d %d  [%d]\n",
          cnt, gx, gy, gz, mx, my, mz, grp );
      }
    }
  }
  fclose( fp );


  if ( print_input ) {
    calib.PrintValues();
    // { int i; scanf("%d", &i); }
    // calib.CheckInput();
    // { int i; scanf("%d", &i); }
    calib.PrintGroups();
  }

  calib.PrepareOptimize();
  
  switch ( mode ) {
  case MODE_PT:
    iter = calib.Optimize( delta, error, max_it );
    break;
#ifdef EXPERIMENTAL
  case MODE_GRAD:
    iter = calib.Optimize2( delta, error, max_it );
    break;
  case MODE_DELTA:
    iter = calib.OptimizeBest( delta, error, max_it );
    break;
  case MODE_FIX_G:
    {
      // TODO set the G coeffs
      Vector b( 0.0037, -0.0725, -0.0300);
      Vector ax( 1.7678, -0.0013, 0.0119);
      Vector ay( -0.0023, 1.7657, -0.0016);
      Vector az(-0.0112, -0.0016, 1.7660);
      Matrix a( ax, ay, az );
      iter = calib.Optimize( delta, error, max_it );
      fprintf(stdout, "Iterations %d\n",  iter);
      fprintf(stdout, "Delta      %.4f\n", delta );
      fprintf(stdout, "Max error  %.4f\n", error );
      calib.PrintCoeffs();
      delta = 0.5;
      iter = 0;
      error = 0.0;
      calib.SetGCoeffs( a, b );
      iter = calib.OptimizeM( delta, error, max_it );
    }
    break;
  case MODE_ITER:
    /*
    Vector b( 0.0037, -0.0725, -0.0300);
    Vector ax( 1.7678, -0.0013, 0.0119);
    Vector ay( -0.0023, 1.7657, -0.0016);
    Vector az(-0.0112, -0.0016, 1.7660);
    Matrix a( ax, ay, az );
    calib.SetGCoeffs( a, b );
    */
    iter = calib.OptimizeIterative( delta, error, max_it );
    break;
#ifdef USE_GUI
  case MODE_PT_DISPLAY:
    calib.SetShowGui( true );
    iter = calib.Optimize( delta, error, max_it );
    // OptimizeExp( delta, error, max_it, true );
    break;
  case MODE_DELTA_DISPLAY:
    calib.SetShowGui( true );
    iter = calib.OptimizeBest( delta, error, max_it, true );
    break;
#endif
#endif // EXPERIMENTAL
  default:
    fprintf(stderr, "Unexpected calibration mode %d\n", mode );
    break;
  }

  fprintf(stdout, "Iterations  %d\n",  iter);
  fprintf(stdout, "Delta       %.4f\n", delta );
  fprintf(stdout, "Max error   %.4f\n", error );
  fprintf(stderr, "M dip angle %.2f\n", calib.GetDipAngle() );
  if ( verbose ) {
    calib.PrintCoeffs();
    // calib.CheckInput();
  }

#if 0
  unsigned char data[48];
  calib.GetCoeff( data );
  for (int k=0; k<48; ++k) {
    printf("0x%02x ", data[k] );
    if ( ( k % 4 ) == 3 ) printf("\n");
  }
#endif

  if ( out_file != NULL ) {
    calib.PrintCalibrationFile( out_file );
  }

  return 0;
}
Exemplo n.º 25
0
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QString openFilename = NULL;
    if (a.arguments().count() > 1) {
        QFile *oFile = new QFile(a.arguments()[1]);
        if (oFile->exists()) {
            openFilename = oFile->fileName();
        }
    }
    QSplashScreen *splash = new QSplashScreen;
    splash -> setPixmap(QPixmap(":/images/splash.png"));
    splash->show();
    QTimer::singleShot(2000,splash,SLOT(close())); //Start splash screen and keep it 2 seconds
#ifdef Q_OS_LINUX
    systExp = "linuxAutre"; //Operating system of the user
    QFile fileOs ("/etc/os-release");
    if (fileOs.exists())
    {
        fileOs.open(QFile::ReadOnly);
        QTextStream stream (&fileOs);
        QString osTxt = stream.readAll();
        if (osTxt.contains("ID=slackware")) {
            systExp = "linuxSlackware";
        }
        else if (osTxt.contains("ID=ubuntu") || osTxt.contains("ID=debian")) {
            systExp = "linuxDebian";
        }
        else if (osTxt.contains("ID=arch") || osTxt.contains("ID=manjaro")) {
            systExp = "linuxArch";
        }
        fileOs.close();
    }
#else
    systExp = "windows";
#endif

    //Define confFile:
    confFile  = confDir +".config";

    //Set locale:
    QString locale = QLocale::system().name();
    appI18n = locale.split("_")[0] == "fr" ? "fr" : "en";

    //Load config:
    QFile configFile(confFile);
    if (configFile.exists()) {
        Functions::loadConfig();
    }
    QTranslator translator;
    translator.load(QString("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
    QString trFile = ":/i18n/qrecipewriter_"+ appI18n +".qm";
    if (QFile(trFile).exists()) {
        translator.load(trFile);
    }
    a.installTranslator(&translator);

    //Define other variables:
    QString tmp = confDir + ".cats";
    confCatFile = new QFile(tmp);
    #ifdef Q_OS_LINUX
    QFile fileDictTest1 ("/usr/share/myspell/dicts/fr_FR.dic");
    QFile fileDictTest2 ("/usr/share/myspell/dicts/fr_FR.aff");
    if (fileDictTest1.exists() && fileDictTest2.exists())
    {
        corrOrtho = "/usr/share/myspell/dicts/fr_FR";
    }
    #else
        #if _WIN64
            QFile fileDictTest1 ("C:/hunspellX64/dicts/fr.dic");
            QFile fileDictTest2 ("C:/hunspellX64/dicts/fr.aff");
            if (fileDictTest1.exists() && fileDictTest2.exists())
            {
                corrOrtho = "C:/hunspellX64/dicts/fr";
            }
        #else
            QFile fileDictTest1 ("C:/hunspellI686/dicts/fr.dic");
            QFile fileDictTest2 ("C:/hunspellI686/dicts/fr.aff");
            if (fileDictTest1.exists() && fileDictTest2.exists())
            {
                corrOrtho = "C:/hunspellI686/dicts/fr";
            }
        #endif
    #endif

    QRecipeWriter w;
    w.openStartupFile = openFilename;

    //Define Dialogs:
    Apropos *apropos = new Apropos(&w);
    ptr2apropos = apropos;
    QDir tmpD (dirTmp);
    if (configFile.exists())
    {
        w.init();
        if (!tmpD.exists())
        {
            tmpD.mkpath(".");
        }
        QTimer::singleShot(2000,&w,SLOT(launch())); //Start the application
    }
    else
    {
        QTimer::singleShot(2000,&w,SLOT(config())); //Start initial config
    }
    return a.exec();
}
Exemplo n.º 26
0
// test distance from point h.p to a line segment going from (x,y) to
// (x+s,y+t) (z=0).
i S(f x,f y,f s,f t,q& h) {
  v a(x,y), d(s,t);
  f u=(h.p-a)%d/(d%d);
  h(a+d*U(u));
}
Exemplo n.º 27
0
/**
 * Process entry
 *
 * @param argc - number of arguments
 * @param argv - pointer to pointers of arguments
 */
int main( int argc, char **argv )
{
	try
	{
		PieDock::Settings settings;
		char *menuName = 0;

		// parse arguments
		{
			char *binary = basename( *argv );

			while( --argc )
				if( **++argv == '-' )
					switch( *((*argv)+1) )
					{
						default:
							std::cerr << "Skipping unknown flag '" <<
								*((*argv)+1) << "'" << std::endl;
							break;
						case '?':
						case 'h':
							std::cout <<
								binary << " [hvrm]" << std::endl <<
								"\t-h         this help" << std::endl <<
								"\t-v         show version" << std::endl <<
								"\t-r FILE    path and name of alternative " <<
									"configuration file" << std::endl <<
								"\t-m [MENU]  show already running " <<
									"instance" << std::endl;
							return 0;
						case 'v':
							std::cout <<
								binary << " 1.6.7" <<
								std::endl <<
								"Copyright (c) 2007-2014" <<
								std::endl <<
								"Markus Fisch <*****@*****.**>" <<
								std::endl <<
								std::endl <<
								"Tatiana Azundris <*****@*****.**>" <<
								std::endl <<
								"* Modifier masks for key control" <<
								std::endl <<
								std::endl <<
								"Jonas Gehring <*****@*****.**>" <<
								std::endl <<
								"* Custom button actions for menus and icons" <<
								std::endl <<
								"* Better tokenization of settings statements" <<
								std::endl <<
								std::endl <<
								"Licensed under the MIT license:" <<
								std::endl <<
								"http://www.opensource.org/licenses/mit-license.php" <<
								std::endl;
							return 0;
						case 'r':
							if( !--argc )
								throw std::invalid_argument(
									"missing FILE argument" );
							settings.setConfigurationFile( *++argv );
							break;
						case 'm':
							if( argc > 1 &&
								**(argv+1) != '-' )
							{
								--argc;
								menuName = *++argv;
							}
							break;
					}
				else
					std::cerr << "skipping unknown argument \"" <<
						*argv << "\"" << std::endl;

			if( settings.getConfigurationFile().empty() )
				settings.setConfigurationFileFromBinary( binary );
		}

		switch( fork() )
		{
			default:
				// terminate parent process to detach from shell
				return 0;
			case 0:
				// pursue in child process
				break;
			case -1:
				throw std::runtime_error( "cannot fork" );
		}

#ifdef HAVE_GTK
		gtk_init( &argc, &argv );
#endif

#ifdef HAVE_KDE
		QApplication q( argc, argv );
#endif

		// always open display after fork
		PieDock::Application a( settings );

		// if another instance is already running, wake it
		if( a.remote( menuName ) )
			return 0;

		// obtain new process group
		setsid();

		signal( SIGCHLD, signalHandler );
		signal( SIGHUP, signalHandler );
		signal( SIGINT, signalHandler );
		signal( SIGTERM, signalHandler );

#ifdef HAVE_KDE
		int r = a.run( &stop );
		q.quit();
		return r;
#else
		return a.run( &stop );
#endif
	}
	catch( std::exception &e )
	{
		std::cerr << "error: " << e.what() << std::endl;

		return -1;
	}
}
Exemplo n.º 28
0
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);

	//Init the logger
	QsLogging::Logger& logger = QsLogging::Logger::instance();
	logger.setLoggingLevel(QsLogging::TraceLevel);
#ifdef Q_OS_WIN
	QString appDataDir = QString(getenv("%USERPROFILE%")).replace("\\","/");
#else
	QString appDataDir = getenv("HOME");
#endif
	QDir appDir(appDataDir);
	if (appDir.exists())
	{
		if (!appDir.cd("EMStudio"))
		{
			appDir.mkdir("EMStudio");
			appDir.cd("EMStudio");
		}
		if (!appDir.cd("applogs"))
		{
			appDir.mkdir("applogs");
		}
	}
	const QString sLogPath(QDir(appDataDir + "/EMStudio/applogs").filePath("log.txt"));

	QsLogging::DestinationPtr fileDestination(QsLogging::DestinationFactory::MakeFileDestination(sLogPath, true, 0, 100));
	QsLogging::DestinationPtr debugDestination(QsLogging::DestinationFactory::MakeDebugOutputDestination());
	logger.addDestination(debugDestination);
	logger.addDestination(fileDestination);

	QString port = "";
	bool autoconnect = true;
	QString plugin = "";
	QList<QPair<QString,QString> > args = getArgs(argc,argv);
	for (int i=0;i<args.size();i++)
	{
		if (args[i].first == "--dev" || args[i].first == "-d")
		{
			port = args[i].second;
		}
		else if (args[i].first == "--help" || args[i].first == "-h")
		{
			printHelp();
			return 0;
		}
		else if (args[i].first == "--autoconnect" || args[i].first == "-a")
		{
			if (args[i].second.toLower() == "false")
			{
				autoconnect = false;
			}
		}
		else if (args[i].first == "--plugin" || args[i].first == "-p")
		{
			plugin = args[i].second;
		}
		else
		{
			qDebug() << "Unknown command" << args[i].first;
			printHelp();
			return 0;
		}
	}

	MainWindow *w = new MainWindow();
	if (port != "")
	{
		w->setDevice(port);
	}
	if (plugin == "")
	{
		//If no plugin is specified, load some reasonable defaults.
		if (QFile::exists("plugins/libfreeemsplugin.so"))
		{
			plugin = "plugins/libfreeemsplugin.so";
		}
		else if (QFile::exists("/usr/share/yats/plugins/libfreeemsplugin.so"))
		{
			plugin = "/usr/share/yats/plugins/libfreeemsplugin.so";
		}
		else if (QFile::exists("plugins/freeemsplugin.lib"))
		{
			plugin = "plugins/freeemsplugin.lib";
		}
		else if (QFile::exists("plugins/libfreeemsplugin.a"))
		{
			plugin = "plugins/libfreeemsplugin.a";
		}
		else if (QFile::exists("plugins/freeemsplugin.dll"))
		{
			plugin = "plugins/freeemsplugin.dll";
		}
		else if (QFile::exists("../../../plugins/libfreeemsplugin.dylib"))
		{
			plugin = "../../../plugins/libfreeemsplugin.dylib";
		}
		else if (QFile::exists("/usr/share/yats/plugins/libfreeemsplugin.dylib"))
		{
			plugin = "/usr/share/yats/plugins/libfreeemsplugin.dylib";
		}
	}
	w->setPlugin(plugin);
	if (autoconnect)
	{
		w->connectToEms();
	}
	w->show();
	return a.exec();
}
Exemplo n.º 29
0
main() {
  void (*a)() = (void *)code;
  printf("size: %d bytes\n", sizeof(code));
  a();
}
Exemplo n.º 30
0
int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	
	// No CLI arguments
	if (argc == 1) {
		try{
			MainWindow w;
			w.show();
			return a.exec();
		} catch(std::out_of_range e) {
			std::cout<<"Out-of-range: "<<e.what()<<std::endl;
		} catch(const char e[]) {
			qDebug() << "EXCEPTION: "<<e;
		} catch(QString e) {
			qDebug() << "EXCEPTION: "<<e;
		}
		return -1;
	}
	
	
	// COMMAND-LINE INTERFACE
	
	// Common variables
	QString imagePath(QDir::currentPath()), featureName, indexer("Sequential indexer"), trainingSet("training_set.txt"), params, queryImage;
	QStringList optimizeVars;
	int useIndex(-1);
	int verbosityLevel(0);
	QStringList qargv = a.arguments(); // Shortcut for argv as QStringList
	
	// Arguments parser
	for (int i(1); i<argc; i++) {
		if (qargv[i] == "-help") {
			usage();
			return 0;
		}
		
		else if (qargv[i] == "-path") {
			if (i+1 == argc) {
				std::cerr << "Error: -path requires an argument: path to images\n\n";
				usage();
				return -1;
			}
			imagePath = qargv[i+1];
			i++;
			//std::cerr << "Path " << imagePath.constData()-> << "\n\n";
			//qDebug() << "Path" << imagePath;
		}
		
		else if (qargv[i] == "-feature") {
			if (i+1 == argc) {
				std::cerr << "Error: -feature requires an argument: name of feature\n\n";
				usage();
				return -1;
			}
			featureName = qargv[i+1];
			i++;
			//qDebug() << "Ft" << featureName;
		}
		
		else if (qargv[i] == "-indexer") {
			if (i+1 == argc) {
				std::cerr << "Error: -indexer requires an argument: name of indexer\n\n";
				usage();
				return -1;
			}
			indexer = qargv[i+1];
			i++;
		}
		
		else if (qargv[i] == "-optimize") {
			if (i+1 == argc) {
				std::cerr << "Error: -optimize requires an argument: comma separated list of variables to optimize\n\n";
				usage();
				return -1;
			}
			optimizeVars = qargv[i+1].split(',');
			i++;
			//qDebug() << "Optimize" << optimizeVars;
		}
		
		else if (qargv[i] == "-trainingset") {
			if (i+1 == argc) {
				std::cerr << "Error: -trainingset requires an argument: filename of list of files for optimizer training\n\n";
				usage();
				return -1;
			}
			trainingSet = qargv[i+1];
			i++;
		}
		
		else if (qargv[i] == "-reuseindex") {
			int idx(0);
			// Check if second parameter is index number
			if (i+1 < argc) {
				bool ok;
				idx = qargv[i+1].toInt(&ok);
				if (!ok) idx=0;
				else i++;
			}
			useIndex = idx;
		}
		
		else if (qargv[i] == "-params") {
			if (i+1 == argc) {
				std::cerr << "Error: -params requires an argument: semicolon separated list of params\n\n";
				usage();
				return -1;
			}
			params = qargv[i+1];
			i++;
		}
		
		else if (qargv[i] == "-query") {
			if (i+1 == argc) {
				std::cerr << "Error: -query requires an argument: path to query image\n\n";
				usage();
				return -1;
			}
			queryImage = qargv[i+1];
			i++;
		}
		
		else if (qargv[i] == "-verbose") {
			verbosityLevel++; // TODO: add more levels
		}

		else {
			std::cerr << "Error: argument not recognized: "<<argv[i]<<"\n\n";
			usage();
			return -1;
		}
	}
	
	// No feature name given - nothing to do
	if (useIndex == -1 && featureName.isEmpty()) {
		std::cerr << "Error: you must specify -featurename with that option\n\n";
		usage();
		return -1;
	}
	
	// Start work
	Indexer* idx;
	ImageFeatures* feature;
	
	try {
	if (useIndex == -1) {
		feature = ImageFeatures::factory(featureName);
		if (!params.isEmpty()) {
			// Check for invalid params
			try {
				feature->setParams(params);
			} catch (QString s) {
				qDebug() << s;
				return -1;
			} catch (const char e[]) {
				std::cerr << e << std::endl;
				return -1;
			}
		}

		idx = Indexer::factory(indexer, feature, imagePath);
		if (verbosityLevel>0) std::cerr << "Building first index...\n";
		
		double t1 = getTime();
		idx->buildIndex();
		double t2 = getTime();
		if (verbosityLevel>0) std::cerr << "Indexing time: " << t2 << " ms\n";
	} else {
		idx = Indexer::createIndex(imagePath, useIndex);
		feature = idx->getAlgorithm();
	}
	
	// Query a single image
	if (!queryImage.isEmpty()) {
		QVector<Indexer::Result> results = idx->search(queryImage);
		for (int i(0); i<results.size(); i++)
			std::cout << results[i].fileName.toAscii().data() << "   " << results[i].distance << std::endl;
		return 0;
	}
	
	PRTest prtest(imagePath, feature, idx);
	if (!prtest.loadCategories()) {
		std::cerr << "Error: failed to load categories.\nDo you have a file named categories.txt in work path?\n";
		return -2;
	}
	
	// If not optimize, do a simple PR test
	if (optimizeVars.isEmpty()) {
		if (verbosityLevel>0) std::cerr << "Starting PRtest...\n";
		double t1 = getTime();
		prtest.execute();
		double t2 = getTime();
		std::cout << "MAP = "<<prtest.MAP << " AP16 = "<<prtest.AP16<<" AWP16 = "<<prtest.AWP16<<" ANMRR = "<<prtest.ANMRR<<std::endl;
		if (verbosityLevel>0) std::cerr << "PRtest time: " << t2 << " ms\n";
	}
	
	// Do optimize run
	else {
		// TODO: use signals-slots to read values from PRtest class and output while using verbosity level etc.
		prtest.optimize(optimizeVars, trainingSet);
	}
	
	} catch(std::out_of_range e) {
		std::cout<<"Out-of-range: "<<e.what()<<std::endl;
	} catch(const char e[]) {
		qDebug() << "EXCEPTION: "<<e;
	} catch(QString e) {
		qDebug() << "EXCEPTION: "<<e;
	}
	
	return 0;
}