Ejemplo n.º 1
0
bool League::finished() {
    //calculate games count
    //
    int max;
    if (clubs.count() %2 == 0)
    {
       max = ((clubs.count()-1)*2)*(clubs.count() /2);

    }
    else {
        int count = clubs.count() + 1;
        max = ((count-1)*2)*(count/2);
    }
//смотрим максимальный сыгранный тур
QSqlQuery q;
q.prepare("SELECT COUNT (*) FROM Matches");
if (!q.exec()) {qDebug() << "SQL Error: " + q.lastError().text() + ", query " + q.executedQuery();}
else {qDebug() << "Query done: " + q.executedQuery();}
q.first();
if (max <= q.value(0).toInt()) {
    writeResults();
    return true;
}
else
    return false;

}
Ejemplo n.º 2
0
void advanced_quit (void)
{

	if (!USE_PRIMENET) {
		outputLongLine (MANUAL_QUIT);
		if (askYesNo ('N')) {
			writeResults ("Quitting GIMPS.\n");
//bug - either delete file, or delete all work_units and write the file.
//bug			IniDeleteAllLines (WORKTODO_FILE);
			stop_workers_for_escape ();
		}
	} else {
		int	res;
		outputLongLine (PRIMENET_QUIT);
		res = askYesNoCancel ('C');
		if (res == 0) {
			OutputBoth (MAIN_THREAD_NUM, "Quitting GIMPS after current work completes.\n");
			IniWriteInt (INI_FILE, "NoMoreWork", 1);
			askOK ();
		}
		if (res == 1) {
			OutputBoth (MAIN_THREAD_NUM, "Quitting GIMPS immediately.\n");
			spoolMessage (MSG_QUIT_GIMPS, NULL);
			askOK ();
		}
	}
}
Ejemplo n.º 3
0
int main(int argc, char *argv[])
/* Read snp126. */
/* Write coords of multiple alignments to .tab file. */
/* Write counts to .log file. */
{

if (argc != 2)
    usage();

snpDb = argv[1];
hSetDb(snpDb);

outputFileHandle = mustOpen("snpMultiple.tab", "w");
logFileHandle = mustOpen("snpMultiple.log", "w");

readSnps();
writeResults();

// free hashes

carefulClose(&outputFileHandle);
carefulClose(&logFileHandle);

return 0;
}
Ejemplo n.º 4
0
int main(int argc, char *argv[])
{
if (argc != 4)
    usage();

database = argv[1];
hSetDb(database);
snpSimpleTable = argv[2];
if (!hTableExistsDb(database, snpSimpleTable))
    errAbort("can't get table %s\n", snpSimpleTable);
orthoTable = argv[3];
if (!hTableExistsDb(database, orthoTable))
    errAbort("can't get table %s\n", orthoTable);

outputFileHandle = mustOpen("snpOrthoJoin.tab", "w");
missingFileHandle = mustOpen("snpOrthoJoin.missing", "w");

chimpHash = getOrtho(orthoTable, "panTro2");
macaqueHash = getOrtho(orthoTable, "rheMac2");
writeResults(snpSimpleTable);

carefulClose(&outputFileHandle);
carefulClose(&missingFileHandle);

return 0;
}
Ejemplo n.º 5
0
int main(int argc, char** argv) {
	uint32_t matchAlgorithm = 0;
	const char* outputFile = "displacements.result";
	const char* imageSequenceFolder = nullptr;

	const ImageProc::ImageProc* imProc = new ImageProc::ImageProcBase();
	Draw::DrawInterface* drawer = new Draw::Draw();
	const Displacement::DisplacementInterface* displacement = new Displacement::DisplacementBase();
	InputMethod::InputMethodInterface* inputMethod = nullptr;
	OutputMethod::OutputImageSequence* outputMethod = new OutputMethod::OutputImageSequence();

	const Descriptor::DescriptorInterface* descriptor = nullptr;
	const Match::MatcherInterface* matcher = nullptr;

	if (argc > 1) {
		imageSequenceFolder = argv[1];
	} else {
		LOG_ERROR("Image sequence folder not defined");
		return -1;
	}
	if (argc > 2) {
		matchAlgorithm = (uint32_t) std::strtoul(argv[2], NULL, 10);
	}
	if (argc > 3) {
		outputFile = argv[3];
	}
	LOG_INFO("Using %s", getMethodPname(matchAlgorithm));

	if (getInputMethod(imageSequenceFolder, &inputMethod) != GBL::RESULT_SUCCESS) {
		LOG_ERROR("Could not deduce a valid input method");
		return -1;
	}

	if (getExecutors(matchAlgorithm, &descriptor, &matcher) != GBL::RESULT_SUCCESS) {
		LOG_ERROR("Could not get valid descriptor and matcher. Define a valid algorithm to be used.");
		return -1;
	}

	clock_t tStart = clock();
	int64_t startTime = GetTimeMs64();
	std::vector<GBL::Displacement_t> displacements = findTheBall(imageSequenceFolder, imProc, *drawer, *descriptor, *matcher, *displacement, *inputMethod, *outputMethod);
	int64_t endTime = GetTimeMs64();
	float_t totalTimeElapsed = (float_t) (clock() - tStart) / CLOCKS_PER_SEC;
	LOG(stdout, "TIME", "CPU time of processing stage: %f s", totalTimeElapsed);
	LOG(stdout, "TIME", "Execution time of processing stage: %f s", (float_t ) (endTime - startTime) / 1000.0f);

	if (writeResults(outputFile, displacements) != GBL::RESULT_SUCCESS) {
		LOG_WARNING("Could not write results to file %s", outputFile);
	}

	delete imProc;
	delete descriptor;
	delete matcher;
	delete displacement;
	delete drawer;
	delete inputMethod;

	return 0;
}
Ejemplo n.º 6
0
void RunExhaustiveDocsimSearch()
{
  const char *topicoutput = Config("RESULTS-PATH");
  FILE *fo;
  if (topicoutput) {
    fo = fopen(topicoutput, "wb");
    if (!fo) {
      fprintf(stderr, "The results file \"%s\" could not be opened for writing.\n", topicoutput);
      exit(1);
    }
  } else {
    fo = stdout;
  }
  
  unsigned char *sigFile;
  SignatureHeader sigCfg = readSigFile(Config("SIGNATURE-PATH"), &sigFile);

  int threadCount = 1;
  int searchDocFirst = 0;
  int searchDocLast = (sigCfg.num_signatures - 1);
  if (Config("THREADS")) {
    threadCount = atoi(Config("THREADS"));
  }
  if (Config("SEARCH-DOC-FIRST"))
    searchDocFirst = atoi(Config("SEARCH-DOC-FIRST"));
  if (Config("SEARCH-DOC-LAST"))
    searchDocLast = atoi(Config("SEARCH-DOC-LAST"));
  int totalDocs = searchDocLast - searchDocFirst + 1;
  void **threads = malloc(sizeof(void *) * threadCount);
  for (int i = 0; i < threadCount; i++) {
    WorkerThroughput *threadData = malloc(sizeof(WorkerThroughput));
    threadData->sig_cfg = &sigCfg;
    threadData->sigFile = sigFile;
    threadData->doc_begin = totalDocs * i / threadCount + searchDocFirst;
    threadData->doc_end = totalDocs * (i+1) / threadCount + searchDocFirst;
    threads[i] = threadData;
  }

  Timer T = StartTimer();

  DivideWork(threads, Throughput_Job, threadCount);

  for (int i = 0; i < threadCount; i++) {
    WorkerThroughput *thread_data = threads[i];
    int doc_count = thread_data->doc_end - thread_data->doc_begin;
    for (int j = 0; j < doc_count; j++) {
      int topicId = thread_data->doc_begin + j;
      const char *docName = (const char *)(sigFile + (size_t)sigCfg.sig_record_size * topicId);
      writeResults(fo, topicId, docName, &thread_data->output[j]);
    }
  }

  fprintf(stderr, "search time %.2fms\n", TickTimer(&T));

  for (int i = 0; i < threadCount; i++) {
    free(threads[i]);
  }
  free(threads);
}
Ejemplo n.º 7
0
PrintDialog::PrintDialog(QWidget* a_parent) :
	QDialog(a_parent)
{
	m_ui.setupUi(this);
	connect(m_ui.m_action_print, SIGNAL(triggered()), this, SLOT(sPrint()));

	writeResults();
}
Ejemplo n.º 8
0
int readFromFile (const char *finput, const char *foutput) {
    if (!finput) {
        printf("Не сте въвели файл за четене\n");
        return 0;
    }

    FILE *input;

    // file read vars
    char *line = NULL;
    size_t len = 0;
    ssize_t charactersRead;

    // comment vars
    const char pattern[3] = "/*";
    char *token;
    int inComment = 0;

    // result vars
    int ifCount = 0;
    int elseCount = 0;
    int linesCount = 0;

    input = fopen(finput, "r");

    while ((charactersRead = getline(&line, &len, input)) != -1) {
        linesCount += 1;

        token = strtok(line, pattern);
        if (token != NULL) {
                printf("inComment: %d Token: %s\n", inComment, token);
                printf("Equal: %d\n", strcmp(token, line));
            while( token != NULL ) {
                if (strcmp(token, line) && searchThroughString(line, "/*")) {
                    inComment = 1;
                    break;
                } else if (strcmp(token, line) && searchThroughString(line, "*/")) {
                    inComment = 0;
                    break;
                }

                if (!inComment) {
                    ifCount += searchThroughString(token, "if");
                    elseCount += searchThroughString(token, "else");
                }
                token = strtok(NULL, pattern);
                if (token != NULL) inComment = !inComment ;
            }
        }
    }

    fclose(input);

    writeResults(foutput, ifCount, elseCount, linesCount);

    return 0;
}
Ejemplo n.º 9
0
int main(int argc, char *argv[])
/* generate snpOrtho table from snp ortho file */
/* combine with snp table */
{
if (argc != 4)
    usage();

hSetDb(argv[1]);
if (!hTableExistsDb(argv[1], argv[2]))
    errAbort("can't get table %s\n", argv[2]);
if (!fileExists(argv[3]))
    errAbort("can't find %s\n", argv[3]);

orthoHash = getOrtho(argv[3]);
writeResults(argv[2]);

return 0;
}
Ejemplo n.º 10
0
int readFromStdin (const char *foutput) {
    // input read vars
    char *line = NULL;
    size_t len = 0;
    ssize_t charactersRead;

    // comment vars
    const char pattern[3] = "/*";
    char *token;
    int inComment = 0;

    // result vars
    int ifCount = 0;
    int elseCount = 0;
    int linesCount = 0;

    while ((charactersRead = getline(&line, &len, stdin)) != -1) {
        linesCount += 1;

        token = strtok(line, pattern);
        if (token != NULL) {
            while( token != NULL ) {
                if (strcmp(token, line) && searchThroughString(line, "/*")) {
                    inComment = 1;
                    break;
                } else if (strcmp(token, line) && searchThroughString(line, "*/")) {
                    inComment = 0;
                    break;
                }

                if (!inComment) {
                    ifCount += searchThroughString(token, "if");
                    elseCount += searchThroughString(token, "else");
                }
                token = strtok(NULL, pattern);
                if (token != NULL) inComment = !inComment ;
            }
        }
    }

    writeResults(foutput, ifCount, elseCount, linesCount - 1);

    return 0;
}
int main(int argc, char *argv[])
{
if (argc != 4)
    usage();

database = argv[1];
hSetDb(database);
snpTable = argv[2];
if (!hTableExistsDb(database, snpTable))
    errAbort("can't get table %s\n", snpTable);
orthoTable = argv[3];
if (!hTableExistsDb(database, orthoTable))
    errAbort("can't get table %s\n", orthoTable);

snpHash = getBaseSnpData(snpTable);
outputFileHandle = mustOpen("snpOrthoLookup.tab", "w");
writeResults(orthoTable);
carefulClose(&outputFileHandle);

return 0;
}
Ejemplo n.º 12
0
int main() {
   int n, a;

   Vert vertices;
   std::vector<int> distances;
   std::vector<int> toConsider;
   std::set<std::vector<int>,CompareResults> results;

   printf("Liczba wierzcholkow wielokata: \n");
   scanf("%d", &n);

   createPolygon(n, vertices);

   printf("Konfiguracja do zbadania:\n");
   
   for (int i = 0; i < 6; ++i) {
       scanf("%d", &a);
       distances.push_back(a);
   }

   transformDistancesToVertex(distances, toConsider);
   checkAllPairs(toConsider, vertices, results);
   writeResults(results);
}
Ejemplo n.º 13
0
void Game::startGame()
{
   //Demarrer les threads
   for(int i = 0; i < nbPlayers_; i++)
      players_[i]->startPlayingAsync();

   populateGrid(10);
   //Condition pour continuer a jouer (genre s'il reste des cases cachees)
   while(remaining_ > 0)
      loop();

#ifndef NO_OUT
   system("cls");
   printGrille(*mirroir_);
#endif

   writeResults();


   //Liberer les joueurs, leur dire de rentrer au vestiaire prendre une douche
   for(int i = 0; i < nbPlayers_; i++)
   {
      //Dabord laisser une chance au thread de se terminer normalement
      SetEvent(events_[i]);
   }

   Sleep(1000); //Donner un delais max pour que les threads se terminent
   for(int i = 0; i < nbPlayers_; i++)
   {
      DWORD result = WaitForSingleObject( players_[i]->getThread(), 0);
      // Si le thread est encore actif, le tuer de maniere violente.
      if (result != WAIT_OBJECT_0) 
         players_[i]->stopPlaying();
   }

}
Ejemplo n.º 14
0
int main(int argc, char* argv[])
try {
    const auto prm    = example::initParam(argc, argv);
    const auto cellID = prm.getDefault("cell", 0);

    const auto rset  = example::identifyResultSet(prm);
    const auto init  = Opm::ECLInitFileData(rset.initFile());
    const auto graph = Opm::ECLGraph::load(rset.gridFile(), init);

    auto pvtCC = Opm::ECLPVT::ECLPvtCurveCollection(graph, init);
    if (prm.has("unit")) {
        pvtCC.setOutputUnits(makeUnits(prm.get<std::string>("unit"), init));
    }

    const auto x = CellState{ graph, rset, cellID };

    auto props = std::vector<Property>{};

    for (const auto& prop : enumerateProperties()) {
        if (prm.getDefault(prop.first, false)) {
            props.push_back(Property{ prop.first, (*prop.second)(pvtCC, x) });
        }
    }

    if (! props.empty()) {
        std::cout.precision(16);
        std::cout.setf(std::ios_base::scientific);

        writeResults(x, props);
    }
}
catch (const std::exception& e) {
    std::cerr << "Caught Exception: " << e.what() << '\n';

    return EXIT_FAILURE;
}
Ejemplo n.º 15
0
//Execute par le thread principal (controleur)
int main (int argc, char **argv)
{
    if (argc != 6)
        return EXIT_FAILIURE;

    signal(SIGALRM, sigHandler);

    std::string pathGrilleVide = argv[1];
    std::string pathGrilleSolution = argv[2];
    std::string pathArrivee = argv[3];
    int tempsMax = atoi(argv[4]);
    pathResultat = argv[5];

    int grille[9][9];
    int solution[9][9];

    mainThread = pthread_self();

    loadGrid(pathGrilleVide, grille);
//     printGrid(grille);

    loadGrid(pathGrilleSolution, solution);
// 	printGrid(solution);

    for (int i = 0; i < 5; i++)
    {
        joueurs[i] == 0;
    }

    //creaation des thread joueur par defaut

    joueurs[0] = new Joueur();
    joueurs[1] = new Joueur();
    joueurs[2] = new Joueur();

    joueurs[0]->thread = new pthread_t();
    joueurs[1]->thread = new pthread_t();
    joueurs[2]->thread = new pthread_t();
    int un=1;
    int deux=2;
    int trois=3;
    pthread_create(joueurs[0]->thread, NULL, jouer, &un);
    pthread_create(joueurs[1]->thread, NULL, jouer, &deux);
    pthread_create(joueurs[2]->thread, NULL, jouer, &trois);

    joueurs[0]->tid = 1;
    joueurs[1]->tid = 2;
    joueurs[2]->tid = 3;

    joueurs[0]->etat = "Inconnu";
    joueurs[1]->etat = "Inconnu";
    joueurs[2]->etat = "Inconnu";

    listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[0]->tid, joueurs[0]));
    listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[1]->tid, joueurs[1]));
    listeJoueurs.insert(std::pair<int, Joueur*>(joueurs[2]->tid, joueurs[2]));


    // Creation des deux autres thread
    pthread_t accueil_t;
    pthread_t alarm_t;

    pthread_create(&accueil_t, NULL, accueil, (void*)pathArrivee.c_str());
    pthread_create(&alarm_t, NULL, minuterie, (void*)&tempsMax);

    sem_init(&file1_sem, 0, 0);

    int* empty = findEmpty(grille);
    int col = 0, ln = 0;
    do
    {
        //============================================================
        // BOUCLE POUR TROUVER LES ZERO ET LES ENVOYER DANS LA FILE 1
        if (empty == 0)
            break;


        if (pthread_mutex_trylock(&file1_lock) == 0)
        {
// 	  std::cout<<"je prend le mutex pour le broadcast"<<std::endl;
            if (file1.size() < 4)
            {
                MessageCJ* msg = new MessageCJ();
                msg->colonne = empty[0];
                msg->ligne = empty[1];

                bool duplicate = false;
                std::queue<MessageCJ*> temp;

                while(!file1.empty())
                {

                    temp.push(new MessageCJ((*file1.front())));
                    file1.pop();
                }

                while(!temp.empty())
                {
                    MessageCJ* tmpMsg = new MessageCJ((*temp.front()));
                    file1.push(tmpMsg);
                    temp.pop();
                    if (tmpMsg->colonne == msg->colonne && tmpMsg->ligne == msg->ligne)
                        duplicate = true;

                }

                if (!duplicate)
                {
                    std::list<int> opts = getOptions(grille, msg->colonne, msg->ligne);

                    msg->choiceList = opts;
                    file1.push(msg);
                    pthread_cond_broadcast(&nonEmpty);
// 		      std::cout<<"je broadcast "<<file1.size()<<std::endl;
                    // sem_post(&file1_sem);
                }

                delete empty;

                col = msg->colonne;
                ln = msg->ligne;

            }

            pthread_mutex_unlock( &file1_lock );
// 	    std::cout<<"je rend le mutex pour le broadcast "<<file2.size()<<std::endl;
        }


        //==========================
        //BOUCLE POUR LIRE LA FILE 2

        if(pthread_mutex_trylock(&file2_lock) == 0)
        {
            if (file2.size() > 0)
            {
                _MessageJC* msg = new _MessageJC((*file2.front()));
                file2.pop();
                if (listeJoueurs.find(msg->tid)->second->etat != "Elimine")
                {
//                     std::cout<<"ANS = "<<msg->choice<<" ? "<<solution[msg->colonne][msg->ligne]<<std::endl;
//                     if (msg->choice == 0)
//                         std::cout<<"LE CIEL NOUS TOMBE SUR LA TETE PAR TOUTATIS!!!"<<std::endl;

                    //pthread_cond_broadcast(&nonFullFile2);
                    if (solution[msg->colonne][msg->ligne] == msg->choice)
                    {
                        //If win!
                        grille[msg->colonne][msg->ligne] = msg->choice;
                        Joueur* vainqueur = listeJoueurs.find(msg->tid)->second;
                        vainqueur->score++;
                    }
                    else
                    {
                        //if noob!
                        Joueur* looser = listeJoueurs.find(msg->tid)->second;
                        looser->score--;
                        looser->nbErreur++;
                        if (looser->score <= -10)
                        {

                            eliminateLooser(&listeJoueurs, msg->tid, joueurs);
                            std::cout<<"Better luck next time, NOOB! "<<msg->tid<<std::endl;

                        }

                    }
                }
                pthread_mutex_unlock(&file2_lock);

            }
            else
            {
                pthread_mutex_unlock(&file2_lock);

                sleep(1);
            }
        }


        pthread_mutex_lock(&nouveauJoueurs_lock);
        if (nouveauxJoueurs.size() > 0)
        {
            if (nouveauxJoueurs.front() == 0)
                pthread_cancel(accueil_t);
            else if (playerCount < 5 )
            {


                for (int i = 0; i < 5 && playerCount < 5 && nouveauxJoueurs.size() > 0; i++)
                {
                    if (joueurs[i] == 0)
                    {

                        int id = nouveauxJoueurs.front();
                        if (id == 0)
                            pthread_cancel(accueil_t);
                        else
                        {
                            nouveauxJoueurs.pop();
                            joueurs[i] = listeJoueurs.find(id)->second;
                            playerCount++;
                            joueurs[i]->etat = "Inconnu";
                            pthread_create(joueurs[i]->thread, NULL, jouer, &joueurs[i]->tid);
                        }
                    }
                }
            }
        }
        pthread_mutex_unlock(&nouveauJoueurs_lock);

        empty = findEmpty(grille, col, ln);
        //printGrid(grille);
//         std::cout<<std::endl;
    } while (empty != 0 && nbJoueurActifs() > 0);

    // Si on se rend ici, soit tous les joueurs sont morts, soit on a fini la grille
    int max = 0;
    for (std::map<int, Joueur*>::iterator it = listeJoueurs.begin(); it != listeJoueurs.end(); it++)
    {

        if (it->second->etat == "Inconnu")
        {
            if (it->second->score > max)
                max = it->second->score;
        }
    }

    for (std::map<int, Joueur*>::iterator it = listeJoueurs.begin(); it != listeJoueurs.end(); it++)
    {

        if (it->second->etat == "Inconnu")
        {
            if (it->second->score == max)
                it->second->etat = "Vainqueur";
            else
                it->second->etat = "Perdant";
        }
    }


    pthread_cancel(accueil_t);
    pthread_cancel(alarm_t);

    writeResults();
    dispose();

    return EXIT_SUCCESS;

}
Ejemplo n.º 16
0
static void master(int nslaves, char* parameterFile)
{
  //VARIABLE DECLARATIONS
  time_t startTime, computationStartTime, endTime;
  int rank, i, j, accel, MAX_ITER, *slave_ldAs, total_ldA, rdA, numLambdas, error;
  ISTAinstance_mpi* instance;
  float *xvalue, *result, *b, *lambdas, lambdaStart, lambdaFinish, gamma, step, MIN_FUNCDIFF;
  char regType, xfilename[MAX_FILENAME_SIZE], bfilename[MAX_FILENAME_SIZE], outfilename[MAX_FILENAME_SIZE];

  //START TIMER
  startTime = time(NULL);

  //GET VALUES FROM PARAMETER FILE
  getMasterParams(parameterFile, xfilename, bfilename, outfilename, &rdA, 
		  &numLambdas, &lambdaStart, &lambdaFinish, &gamma, &step, &regType, &accel, 
		  &MAX_ITER, &MIN_FUNCDIFF);

  //STORE EACH SLAVE'S INDIVIDUAL LDA AND CALCULATE TOTAL_LDA
  slave_ldAs = (int*)malloc((nslaves+1)*sizeof(int));
  int my_ldA = 0;
  MPI_Gather(&my_ldA, 1, MPI_INT, slave_ldAs, 1, MPI_INT, 0, MPI_COMM_WORLD);
  total_ldA = 0;
  for(i=0; i<=nslaves; i++)
    total_ldA += slave_ldAs[i];
  fprintf(stdout, "TOTAL LDA IS %d\n", total_ldA);


  //ALLOCATE MEMORY
  xvalue = calloc(rdA+1,sizeof(float));
  result = malloc((total_ldA+rdA)*sizeof(float));
  b      = malloc((total_ldA)*sizeof(float));
  lambdas = malloc(numLambdas*sizeof(float));
  if(xvalue==NULL || result==NULL || b==NULL || lambdas==NULL)
    fprintf(stdout,"Unable to allocate memory!");
  

  //ASSIGN VALUES TO XVALUE AND B
  error=1;
  if(strcmp(xfilename, "zeros")==0){
    //do nothing - calloc already initialized xvalue to 0
  }
  else 
    error *= getVector(xvalue, rdA, xfilename);
  error *= getVector(b, total_ldA, bfilename);

  //CHECK FOR FILEOPEN ERRORS; IF ANY PRESENT END PROGRAM
  for(i=1; i<=nslaves; i++)
    if(slave_ldAs[i] == -1) error=0;
  MPI_Bcast(&error, 1, MPI_INT, 0, MPI_COMM_WORLD);
  if(error==0) {
    free(result);
    free(xvalue);
    free(b);
    free(lambdas);
    return;
  }
  
  //PRINT INPUTS
  /*  fprintf(stdout, "Here's x:\n");
  for(i=0; i < rdA; i++)
    {
      fprintf(stdout, "%f ", xvalue[i]);
    }
  fprintf(stdout, "\n and here's b:\n");
  for(i=0; i < total_ldA; i++)
    {
      fprintf(stdout, "%f ", b[i]);
    }
  */

  //CREATE ISTA OBJECT
  instance = ISTAinstance_mpi_new(slave_ldAs, total_ldA, rdA, b, lambdaStart, gamma, 
				  accel, regType, xvalue, step,
				  nslaves, MPI_COMM_WORLD,
				  TAG_AX, TAG_ATX, TAG_ATAX, TAG_DIE);
  
  //CENTER FEATURES
  float* shifts = calloc(rdA, sizeof(float));
  MPI_Reduce(shifts, instance->meanShifts, rdA, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
  cblas_sscal(rdA, 1.0 / total_ldA, instance->meanShifts, 1); 
  
  MPI_Bcast(instance->meanShifts, rdA, MPI_FLOAT, 0, MPI_COMM_WORLD);

  //SCALE FEATURES
  float* norms = calloc(rdA, sizeof(float));
  MPI_Reduce(norms, instance->scalingFactors, rdA, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
  for(j=0; j<rdA; j++)
    instance->scalingFactors[j] = pow(instance->scalingFactors[j], 0.5);

  MPI_Bcast(instance->scalingFactors, rdA, MPI_FLOAT, 0, MPI_COMM_WORLD); 

  //CREATE LAMBDA PATH
  calcLambdas(lambdas, numLambdas, lambdaStart, lambdaFinish, instance);

  //DEBUGGING AREA
  /*float* ones = calloc(rdA+1, sizeof(float));
  for(i=0; i< rdA+1; i++) {
    ones[i] = 1.0;
  }
  fprintf(stdout, "meanshifts: ");
  for(i=0; i<5; i++) {
    fprintf(stdout, "%f ", instance->meanShifts[i]);
  }
  fprintf(stdout, "\nscalingFactors: ");
  for(i=0; i<5; i++) {
    fprintf(stdout, "%f ", instance->scalingFactors[i]);
  }
  fprintf(stdout, "\nlambdas: ");
  for(i=0; i<5; i++) {
    fprintf(stdout, "%f ", lambdas[i]);
  }
  fprintf(stdout, "\nA * ones: ");
  multiply_Ax(ones, result, instance);
  for(i=0; i<5; i++) {
    fprintf(stdout, "%f ", result[i]);
  }
  fprintf(stdout, "\n");
  */
  
  //TIME UPDATE
  computationStartTime = time(NULL);

  //RUN ISTA
  for(j=0; j < numLambdas; j++) {
    instance->lambda = lambdas[j];

    ISTAsolve_lite(instance, MAX_ITER, MIN_FUNCDIFF);
    fprintf(stdout, "\n");
  }

  //UNDO RESCALING
  for(i=0; i<(instance->rdA); i++) {
    if(instance->scalingFactors[i] > 0.0001)
      instance->xcurrent[i] = instance->xcurrent[i] / instance->scalingFactors[i];
  }
  instance->intercept = -1.0 * cblas_sdot(instance->rdA, instance->xcurrent, 1, instance->meanShifts, 1);

  //WRITE RESULTS
  writeResults(instance, outfilename, bfilename, lambdas[numLambdas-1]);

  //STOP TIME
  endTime = time(NULL);
  fprintf(stdout,"Setup took %f seconds and computation took %f seconds\n",
	  difftime(computationStartTime, startTime), difftime(endTime, computationStartTime));

  //CLOSE THE SLAVE PROCESSES AND FREE MEMORY
  fprintf(stdout, "Closing the program\n");
  for(rank=1; rank <= nslaves; rank++)
    {
      MPI_Send(0, 0, MPI_INT, rank, TAG_DIE, MPI_COMM_WORLD);
    }

  free(result); 
  ISTAinstance_mpi_free(instance); 
  free(shifts); 
  free(norms); 
  free(lambdas);
  return;
}
Ejemplo n.º 17
0
int main() {
    MSS * myResult;

    /* initialize random seed: */
    srand (time(NULL));

    unsigned int sizeOfNum = 512;
    std::vector<int> num;

    createVector(num, sizeOfNum);

    printf("Max Sum Sub-Array Algorithms\n\n");
    printf("size = %d\n\n", sizeOfNum);
    std::clock_t    start;

    printf("\n\nBrute Force Max Sum Sub-Array\n\n");

    start = std::clock();
    bruteMaxSumSub(num, result, sizeOfNum);
    std::cout << "Brute Force Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n";
    printf("Result of bruteMaxSumSub, max sum = %d\nSubArray*************\n", result.sum);
    for(int i = result.start; i <= result.end; ++i) {
        printf("%d\t", num[i]);
    }

    printf("\n\nImproved Brute Force Max Sum Sub-Array\n\n");

    start = std::clock();
    betterBruteMaxSum(num, result, sizeOfNum);
    std::cout << "Better Brute Force Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n";
    printf("Result of betterBruteMaxSumSub, max sum = %d\nSubArray*************\n", result.sum);
    for(int i = result.start; i <= result.end; ++i) {
        printf("%d\t", num[i]);
    }

    printf("\n\nDivide and Conquer Max Sum Sub-Array\n\n");

    start = std::clock();
    myResult = divideAndConquerMaxSub(num, 0, sizeOfNum - 1);
    std::cout << "Divide and Conquer Max Sum Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n";
    printf("Result of divideAndConquerMaxSub, max sum = %d\nSubArray*************\n", myResult->sum);
    for(int i = myResult->start; i <= myResult->end; ++i) {
        printf("%d\t", num[i]);
    }
    //clean up
    delete myResult;
    myResult = NULL;

    printf("\n\nLinear Max Sum Sub-Array\n\n");

    start = std::clock();
    linearMaxSub(num, sizeOfNum, result);
    std::cout << "Linear Max Sum Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms\n";
    printf("Result of linearMaxSub, max sum = %d\nSubArray*************\n", result.sum);
    for(int i = result.start; i <= result.end; ++i) {
        printf("%d\t", num[i]);
    }

    std::cout << std::endl << std::endl;

    /*********************************************************************************************************************************
    **TESTING FILES
    **********************************************************************************************************************************/


    /* Stream class provided by C++ to read from files
    Credit: http://www.cplusplus.com/doc/tutorial/files/*/
    std::ifstream textfile;
    /* In order to open a file with a stream object we use its member function open */
    textfile.open( "MSS_Problems.txt" );
    /* To check if a file stream was successful opening a file, you can do it by calling to member is_open
    Credit: http://www.cplusplus.com/doc/tutorial/files/*/
    if( !textfile.is_open() )
    {
        textfile.close();
        std::cout << "Please add MSS_Problems.txt and try again." << std::endl;
        exit(1);
    }
    /* Stream class to write on files
    Credit: http://www.cplusplus.com/doc/tutorial/files/*/
    std::ofstream textfile2;
    textfile2.open("MSS_Results.txt");
    /* vector of vectors to store number set */
    std::vector<std::vector<int>> setOfNumbers = getNumbers(textfile);

    textfile.close();
    /* Label the results file */
    textfile2 << " Algorithm 1: Enumeration \n";
    std::cout << " Algorithm 1: Enumeration \n" << std::endl;


    /* Run enumeration algorithm on input numbers */
    for( unsigned int i = 0; i < setOfNumbers.size(); i++ )
    {
        bruteMaxSumSub(setOfNumbers.at(i), result, setOfNumbers.at(i).size());
        int total = result.sum;
        int start = result.start;
        int end = result.end;
        /* Call function to output is to be written to MSS_Results.txt */
        std::cout << total << std::endl;
        writeResults( textfile2, setOfNumbers.at(i), start, end, total );
    }
    /* Label the results file */
    textfile2 << " Algorithm 2: Better Enumeration \n";
    std::cout << " Algorithm 2: Better Enumeration \n" << std::endl;
    /* Run better enumeration algorithm on input numbers */
    for( unsigned int i = 0; i < setOfNumbers.size(); i++ )
    {

        betterBruteMaxSum(setOfNumbers.at(i), result, setOfNumbers.at(i).size());
        int total = result.sum;
        int start = result.start;
        int end = result.end;
        /* Call function to output is to be written to MSS_Results.txt */
        std::cout << total << std::endl;
        writeResults( textfile2, setOfNumbers.at(i), start, end, total );
    }
    /* Label the results file */
    textfile2 << " Algorithm 3: Divide and Conquer \n";
    std::cout << " Algorithm 3: Divide and Conquer \n" << std::endl;
    /* Run divide and conquer algorithm on input numbers */
    for( unsigned int i = 0; i < setOfNumbers.size(); i++ )
    {
        myResult = divideAndConquerMaxSub(setOfNumbers.at(i), 0, setOfNumbers.at(i).size()-1);
        int total = myResult->sum;
        int start = myResult->start;
        int end = myResult->end;
        /* Call function to output is to be written to MSS_Results.txt */
        std::cout << total << std::endl;
        writeResults( textfile2, setOfNumbers.at(i), start, end, total );
        //clean up
        delete myResult;
        myResult = NULL;
    }

    /* Label the results file */
    textfile2 << " Algorithm 4: Linear-time \n";
    std::cout << " Algorithm 4: Linear-time \n" << std::endl;
    for( unsigned int i = 0; i < setOfNumbers.size(); i++ )
    {
        linearMaxSub(setOfNumbers.at(i), setOfNumbers.at(i).size(), result);
        int total = result.sum;
        int start = result.start;
        int end = result.end;
        /* Call function to output is to be written to MSS_Results.txt */
        std::cout << total << std::endl;
        writeResults( textfile2, setOfNumbers.at(i), start, end, total );
    }
    textfile2.close();


    //clean up
    delete myResult;
    myResult = NULL;
    return 0;
}
Ejemplo n.º 18
0
// Point d'entree dans le programme
int main(int argc,char** argv)
{
    FILE* transaction_file = fopen(S_LEC,"a+");
    fclose(transaction_file);
    transaction_file = fopen(S_LEC,"r");

    if (transaction_file == NULL) {
        fprintf(stderr,"Impossible d'ouvrir le fichier %s\n",S_LEC);
        return -1;
    }
    char line_buffer[256], message[256];
    int i, flags;
    Connection* connection;
    PRIM_PACKET p;

    // Recuperation des references au tuyaux
    // (respectivement l'ecriture et l'ecoute)
    transToNet_pipe = atoi(argv[1]);
    netToTrans_pipe = atoi(argv[2]);

    // On s'assure que les file descriptors sont en mode 0_NONBLOCK
    flags = fcntl(transToNet_pipe,F_GETFL,0);
    fcntl(transToNet_pipe,F_SETFL, flags | O_NONBLOCK);
    flags = fcntl(netToTrans_pipe,F_GETFL,0);
    fcntl(netToTrans_pipe,F_SETFL, flags | O_NONBLOCK);

    if (DEBUG) printf("TRANSPORT\nMes fd sont:\n%i,%i\n",netToTrans_pipe,transToNet_pipe);

    //ALGO
    //--------
    //TANT QUE FICHIER_NON_VIDE
    //LIRE S_LEC

    //REGARDER_TABLE_DE_CONNEXIONS

    //SI CONNEXION_EXISTE_PAS
    //ENVOYER_CONNECTION_REQ
    //ECOUTER_REPONSE

    //SI REPONSE_POSITIVE
    //CHANGER_ETAT_CONNEXION_TABLE_CONNEXION
    //ENVOYER_DATA_REQ
    //SINON
    //SUPPRIMER_CONNEXION
    //FIN SI
    //SINON
    //ENVOYER_DATA_REQ
    //FIN SI
    //FIN TANT QUE

    //POUR TOUS LES CONNEXION
    //SUPPRIMMER_CONNEXION

    // Lecture du fichier S_LEC, envoie des requetes et ecoute
    // de la reponse.
    while(fgets(line_buffer, 256, transaction_file))
    {
        connection = (Connection*) findConnection(line_buffer[0]);

        // La connexion n'existe pas
        if (!connection/*==NULL*/) {

            // Engager une connexion
            connection = (Connection*) add_connection(line_buffer[0],NULL,NULL);

            // Creaction d'un paquet contenant la primitive N_CONNECT_req
            p.prim = N_CONNECT_req;

            // Genere un seed pour une valeur pseudo-aleatoire
            // differente par rand()
            srand(time(NULL));
            p.con_prim_packet.src_addr = (unsigned char) rand();  // Adresses aleatoires pour la source
            p.con_prim_packet.dest_addr = (unsigned char) rand(); // et la destination..
            p.con_prim_packet.con_number = connection->tcon.con_number;

            // Envoie d'un paquet et ecoute de la reponse de ER
            writePrimPacketToStdOut(&p,I_AM);
            if(sendPacketToInterface(&p,transToNet_pipe) == -1)
                return -1;
            if (getPacketFromInterface(&p,netToTrans_pipe) == -1)
                return -1;

            char result[256];
            // Action en consequence
            switch(p.prim)
            {
            // CON_PRIM_PACKET reçu => N_CONNECT_conf
            case N_CONNECT_conf:
                // Ecriture des resutlats dans S_ECR
                sprintf(result,"Reception de la primitive N_CONNECT.conf sur la connection %c\n", connection->tcon.con_number);
                writeResults(result,S_ECR);

                // Confirmation de la connexion
                connection->tcon.state = 0x01;

                // Construction du paquet de DATA
                p.prim = N_DATA_req;
                getMessageFromBuffer(line_buffer,message);

                strcpy(p.data_prim_packet.transaction,message);
                p.data_prim_packet.con_number = connection->tcon.con_number;

                // Envoie du paquet a l'ER
                writePrimPacketToStdOut(&p,I_AM);
                if(sendPacketToInterface(&p,transToNet_pipe) == -1)
                    return -1;
                break;
            // REL_PRIM_PACKET reçu => N_DISCONNECT_ind
            case N_DISCONNECT_ind:
                // Ecriture des resultats dans S_ECR
                sprintf(result,"Reception de la primitive N_DISCONNECT.ind pour la connexion %c\n",connection->tcon.con_number);
                writeResults(result,S_ECR);

                // Retrait de la connexion de la table de connexions
                remove_connection(connection->tcon.con_number);
                break;
            }
        }
        else {
            // Construction du paquet de DATA
            p.prim = N_DATA_req;
            getMessageFromBuffer(line_buffer,message);
            strcpy(p.data_prim_packet.transaction,message);
            p.data_prim_packet.con_number = connection->tcon.con_number;

            // Envoyer N_DATA.req
            writePrimPacketToStdOut(&p,I_AM);
            if(sendPacketToInterface(&p,transToNet_pipe) == -1)
                return -1;
        }
    }

    // Construction d'un paquet REL_PRIM_PACKET
    // et vidage de la table de connexions
    p.prim = N_DISCONNECT_req;
    connection = first_con_node;
    while (connection) {
        p.rel_prim_packet.con_number = connection->tcon.con_number;
        writePrimPacketToStdOut(&p,I_AM);
        if(sendPacketToInterface(&p,transToNet_pipe) == -1)
            return -1;
        connection = connection->tcon.next;
    }

    deleteAllConnections();

    // Fermeture du fichier S_LEC
    fclose(transaction_file);

    return 0;
}
Ejemplo n.º 19
0
/**************************************************************
 * *  This main function creates a vector of randomly generated integers
 * *  for use in testing the implementations of Algorithms 1-4. The first part measures
 * *  the running time in ms for each Algorithm for display. The second part tests
 * *  input output by reading input from a specified text file, running each Algorithm
 * *  on this input, and writing the results to another specified text file.
 * ***************************************************************/
int main(int argc, char* argv[]){
	std::string filename;
	std::string outputfilename;
	/* The first argument (argc) is the number of elements in the array so we should have two elements the program name and file name 
	Credit: http://www.site.uottawa.ca/~lucia/courses/2131-05/labs/Lab3/CommandLineArguments.html
	*/
    if(argc != 2)
    {
        std::cout << "Please enter an input filename." << std::endl << std::endl;
        exit(1);
    }
	/* which is the second argument (argv). The second argument is always an array of char*, */
    else
    {      
        filename = std::string(argv[1]);
		std::string tempoutputfilename = std::string(argv[1]);
		//http://www.cplusplus.com/reference/string/string/length/
		int strsize = tempoutputfilename.length() - 4;
		/* http://www.cplusplus.com/reference/string/string/operator+/ 
		http://www.cplusplus.com/reference/string/string/substr/ */
		outputfilename = (tempoutputfilename.substr(0, strsize)) + "change.txt";
		std::cout << outputfilename << std::endl;
	}
	//cout << filename << endl;
	/* Stream class provided by C++ to read from files
	Credit: http://www.cplusplus.com/doc/tutorial/files/*/
    std::ifstream textfile;
	/* In order to open a file with a stream object we use its member function open */
    textfile.open(filename);
	/* To check if a file stream was successful opening a file, you can do it by calling to member is_open
	Credit: http://www.cplusplus.com/doc/tutorial/files/*/
    if(!textfile.is_open())
    {
        std::cout << "The file could not be opened." << std::endl;
        textfile.close();
        exit(1);
    }
	/* Call function to put first alternating lines as the coin set input and the second alternating lines as total change V */
    std::vector<std::vector<int>> coinsetinput;
    std::vector<int> changevalueV;
    getinput( textfile, coinsetinput, changevalueV );
    textfile.close();
	/* Stream class to write on files
	Credit: http://www.cplusplus.com/doc/tutorial/files/*/
	std::ofstream textfile2;
    textfile2.open(outputfilename);
    if(!textfile2.is_open())
    {
        std::cout << "Cannot open for writing. Check the permissions of the directory." << std::endl;
        textfile2.close();
        exit(1);
    }
	/* Display a babel for brute force algorithm time trial */
    std::cout << "Testing changeslow...." << std::endl;
    for( unsigned int i = 0; i < coinsetinput.size(); i++ )
    {
        /* Run brute force algorithm on input numbers from first to last element */
		std::vector<int> coinCount;
		runtimetrial( changeslow, coinsetinput.at(i), changevalueV.at(i), coinCount );
    }
	/* Display a babel for greedy algorithm time trial */
    std::cout << "Testing changegreedy...." << std::endl;
    for( unsigned int i = 0; i < coinsetinput.size(); i++ )
    {
        /* Run greedy algorithm on input numbers from first to last element */
		std::vector<int> coinCount;
        runtimetrial( changegreedy, coinsetinput.at(i), changevalueV.at(i), coinCount);
    }
    /* Display a babel for dynamic programming algorithm time trial */
    std::cout << "Testing changedp...." << std::endl;
    /*for( unsigned int i = 0; i < coinsetinput.size(); i++ )
    {
         Run greedy algorithm on input numbers from first to last element 
		
    }*/
	/* Call function to output is to be written to text file */
    textfile2 << "Brute Force \n\n";
	 /* Run changeslow algorithm on input numbers */
    for( unsigned int i = 0; i < coinsetinput.size(); i++ )
    {
        std::vector<int> coinCount;
        int minCoins = changeslow( coinsetinput.at(i), changevalueV.at(i), coinCount );
        writeResults( textfile2, coinCount, minCoins );
    }
	/* Call function to output is to be written to text file */
    textfile2 << "Greedy\n\n";
    for( unsigned int i = 0; i < coinsetinput.size(); i++ )
    {
        std::vector<int> coinCount;
        int minCoins = changegreedy(coinsetinput.at(i), changevalueV.at(i), coinCount);
        writeResults( textfile2, coinCount, minCoins );
    }
	/* Call function to output is to be written to text file */
    textfile2 << "Dynamic Programming\n\n";
    //for( unsigned int i = 0; i < coinsetinput.size(); i++ )
   // {
      //  std::vector<int> coinCount;
       // int minCoins = changedp();
        //writeResults( textfile2, coinCount, minCoins );
	//}
    textfile2.close();	
}
Ejemplo n.º 20
0
void Game::writeResults()
{
#ifndef NO_OUT
   writeResults(std::cout);
#endif
}
Ejemplo n.º 21
0
// Create a grayscale face image that has a standard size and contrast & brightness.
// "srcImg" should be a copy of the whole color camera frame, so that it can draw the eye positions onto.
// If 'doLeftAndRightSeparately' is true, it will process left & right sides seperately,
// so that if there is a strong light on one side but not the other, it will still look OK.
// Performs Face Preprocessing as a combination of:
//  - geometrical scaling, rotation and translation using Eye Detection,
//  - smoothing away image noise using a Bilateral Filter,
//  - standardize the brightness on both left and right sides of the face independently using separated Histogram Equalization,
//  - removal of background and hair using an Elliptical Mask.
// Returns either a preprocessed face square image or NULL (ie: couldn't detect the face and 2 eyes).
// If a face is found, it can store the rect coordinates into 'storeFaceRect' and 'storeLeftEye' & 'storeRightEye' if given,
// and eye search regions into 'searchedLeftEye' & 'searchedRightEye' if given.
cv::Mat preprocessFace::getPreprocessedFace(cv::Mat &srcImg, int desiredFaceWidth, cv::CascadeClassifier &faceCascade, cv::CascadeClassifier &eyeCascade1, cv::CascadeClassifier &eyeCascade2, bool doLeftAndRightSeparately, cv::Rect *storeFaceRect, cv::Point *storeLeftEye, cv::Point *storeRightEye, cv::Rect *searchedLeftEye, cv::Rect *searchedRightEye)
{
	// Use square faces.
	int desiredFaceHeight = desiredFaceWidth;

	// Mark the detected face region and eye search regions as invalid, in case they aren't detected.
	if (storeFaceRect)
		storeFaceRect->width = -1;
	if (storeLeftEye)
		storeLeftEye->x = -1;
	if (storeRightEye)
		storeRightEye->x = -1;
	if (searchedLeftEye)
		searchedLeftEye->width = -1;
	if (searchedRightEye)
		searchedRightEye->width = -1;

	// Find the largest face.
	cv::Rect faceRect;
	detector.detectLargestObject(srcImg, faceCascade, faceRect);

	// Check if a face was detected.
	if (faceRect.width > 0) {

		// Give the face rect to the caller if desired.
		if (storeFaceRect)
			*storeFaceRect = faceRect;

		cv::Mat faceImg = srcImg(faceRect);    // Get the detected face image.

		// If the input image is not grayscale, then convert the BGR or BGRA color image to grayscale.
		cv::Mat gray;
		if (faceImg.channels() == 3) {
			cvtColor(faceImg, gray, CV_BGR2GRAY);
		}
		else if (faceImg.channels() == 4) {
			cvtColor(faceImg, gray, CV_BGRA2GRAY);
		}
		else {
			// Access the input image directly, since it is already grayscale.
			gray = faceImg;
		}

		// Search for the 2 eyes at the full resolution, since eye detection needs max resolution possible!
		cv::Point leftEye, rightEye;
		detectBothEyes(gray, eyeCascade1, eyeCascade2, leftEye, rightEye, searchedLeftEye, searchedRightEye);

		// Give the eye results to the caller if desired.
		if (storeLeftEye)
			*storeLeftEye = leftEye;
		if (storeRightEye)
			*storeRightEye = rightEye;

		// Check if both eyes were detected.
		if (leftEye.x >= 0 && rightEye.x >= 0) 
		{
			inputFaceCount++;

			// Make the face image the same size as the training images.

			// Since we found both eyes, lets rotate & scale & translate the face so that the 2 eyes
			// line up perfectly with ideal eye positions. This makes sure that eyes will be horizontal,
			// and not too far left or right of the face, etc.

			// Get the center between the 2 eyes.
			cv::Point2f eyesCenter = cv::Point2f((leftEye.x + rightEye.x) * 0.5f, (leftEye.y + rightEye.y) * 0.5f);
			// Get the angle between the 2 eyes.
			double dy = (rightEye.y - leftEye.y);
			double dx = (rightEye.x - leftEye.x);
			double len = sqrt(dx*dx + dy*dy);
			double angle = atan2(dy, dx) * 180.0 / CV_PI; // Convert from radians to degrees.

			// Hand measurements shown that the left eye center should ideally be at roughly (0.19, 0.14) of a scaled face image.
			const double DESIRED_RIGHT_EYE_X = (1.0f - DESIRED_LEFT_EYE_X);
			// Get the amount we need to scale the image to be the desired fixed size we want.
			double desiredLen = (DESIRED_RIGHT_EYE_X - DESIRED_LEFT_EYE_X) * desiredFaceWidth;
			double scale = desiredLen / len;
			// Get the transformation matrix for rotating and scaling the face to the desired angle & size.
			cv::Mat rot_mat = getRotationMatrix2D(eyesCenter, angle, scale);
			// Shift the center of the eyes to be the desired center between the eyes.
			rot_mat.at<double>(0, 2) += desiredFaceWidth * 0.5f - eyesCenter.x;
			rot_mat.at<double>(1, 2) += desiredFaceHeight * DESIRED_LEFT_EYE_Y - eyesCenter.y;

			// Rotate and scale and translate the image to the desired angle & size & position!
			// Note that we use 'w' for the height instead of 'h', because the input face has 1:1 aspect ratio.
			cv::Mat warped = cv::Mat(desiredFaceHeight, desiredFaceWidth, CV_8U, cv::Scalar(128)); // Clear the output image to a default grey.
			warpAffine(gray, warped, rot_mat, warped.size());
			//imshow("warped", warped);

			// Give the image a standard brightness and contrast, in case it was too dark or had low contrast.
			if (!doLeftAndRightSeparately) {
				// Do it on the whole face.
				equalizeHist(warped, warped);
			}
			else {
				// Do it seperately for the left and right sides of the face.
				equalizeLeftAndRightHalves(warped);
			}
			//imshow("equalized", warped);

			// Use the "Bilateral Filter" to reduce pixel noise by smoothing the image, but keeping the sharp edges in the face.
			cv::Mat filtered = cv::Mat(warped.size(), CV_8U);
			bilateralFilter(warped, filtered, 0, 20.0, 2.0);
			//imshow("filtered", filtered);

			// Filter out the corners of the face, since we mainly just care about the middle parts.
			// Draw a filled ellipse in the middle of the face-sized image.
			cv::Mat mask = cv::Mat(warped.size(), CV_8U, cv::Scalar(0)); // Start with an empty mask.
			cv::Point faceCenter = cv::Point(desiredFaceWidth / 2, cvRound(desiredFaceHeight * FACE_ELLIPSE_CY));
			cv::Size size = cv::Size(cvRound(desiredFaceWidth * FACE_ELLIPSE_W), cvRound(desiredFaceHeight * FACE_ELLIPSE_H));
			ellipse(mask, faceCenter, size, 0, 0, 360, cv::Scalar(255), CV_FILLED);
			//imshow("mask", mask);

			// Use the mask, to remove outside pixels.
			cv::Mat dstImg = cv::Mat(warped.size(), CV_8U, cv::Scalar(128)); // Clear the output image to a default gray.
			/*
			namedWindow("filtered");
			imshow("filtered", filtered);
			namedWindow("dstImg");
			imshow("dstImg", dstImg);
			namedWindow("mask");
			imshow("mask", mask);
			*/
			// Apply the elliptical mask on the face.
			filtered.copyTo(dstImg, mask);  // Copies non-masked pixels from filtered to dstImg.
			//imshow("dstImg", dstImg);


			/*if (leftEye.x >= 0 && rightEye.x >= 0)
			{
				eyeRegion.x = 0;
				eyeRegion.y = searchedLeftEye.y;
				eyeRegion.width = preprocessedFace.rows;
				eyeRegion.height = 30;
				cv::rectangle(frame, eyeRegion, CV_RGB(255, 255, 0), 3);
			}*/

			if (needResults)
			{
				writeResults(srcImg, gray, dstImg);
			}
			
			return dstImg;
		}
		/*
		else {
		// Since no eyes were found, just do a generic image resize.
		resize(gray, tmpImg, Size(w,h));
		}
		*/
	}
	return cv::Mat();
}
int main(){
	fp = fopen("partitionResult.txt", "w");  
	int i=0;
        scanf("%d", &number_of_vertex);  //3
        scanf("%d", &number_of_edge);   //2
        
        // construct Graph and allocate spaces for each edge
        graph= malloc(sizeof(struct Graph));
        graph->V = number_of_vertex;
        graph->list = malloc(sizeof(AdjList)*graph->V);
        //graph->edgeList = malloc(sizeof(EdgeList)*number_of_edge);

	// allocate space for FreeList
	freeList = malloc(sizeof(FreeList)*number_of_vertex);  // hold the free nodes
	newFreeList = malloc(sizeof(FreeList)*number_of_vertex); // to hold the new freeList 

        for (i=0; i<graph->V; i++) {
       		graph->list[i].head = NULL;
        }
	for (i=0; i<graph->V; i++) { // allocate spaces and give initial values
		freeList[i].gainList = malloc(sizeof(struct GainList*));
		newFreeList[i].gainList = malloc(sizeof(struct GainList*));
		freeList[i].gainList->cell_id = i;
	}	
        
        Nodes *nodes = malloc(sizeof(Nodes)*number_of_edge);
        // take source, destinaton and weight from user and hold them into Nodes list
        for(i=0; i<number_of_edge; i++){
        	Nodes node = malloc(sizeof(Nodes));
        	scanf("%d", &node->src); 
        	scanf("%d", &node->dest);
            	scanf("%d", &node->weight);
            	nodes[i] = node;
        }

        // add edges, make connection between nodes and hold them all in graph->list
        for(i=0; i<number_of_edge;i++){
                
                NodeList *node = malloc(sizeof*node);
                node->random = rand()%2;
                node->dest = nodes[i]->dest;
                node->next = graph->list[nodes[i]->src].head;
                graph->list[nodes[i]->src].head = node;
		// because of undirect
		NodeList *node2 = malloc(sizeof*node2);
		node2->random = rand()%2;
		node2->dest = nodes[i]->src;
		node2->next = graph->list[nodes[i]->dest].head;
		graph->list[nodes[i]->dest].head = node2;
        }

	// initialize GainList
	maxDegree =	findTheMaxDegree();
	headL = malloc(sizeof(struct GainList*)*2*maxDegree+1);
	headR = malloc(sizeof(struct GainList*)*2*maxDegree+1);
	lastL = malloc(sizeof(struct GainList*)*2*maxDegree+1);
	lastR = malloc(sizeof(struct GainList*)*2*maxDegree+1);
		
	initializeGainList();
		
	// fill FreeList
	fillFreeList();
		
		
	int cut;
	int minCut;
	cut = computeCut();
	minCut = INT_MAX;
	printf("Initial Number of Cut %d\n", cut);
	gainCell();
	// display();
	// gain cell
	int j;
	do{	
		for(i=0; i<graph->V;i++){
			// base cell
			int baseCellId = findBaseCell();
			moveBaseCell(baseCellId);
			cut = computeCut();
			if(cut < minCut){ 
				minCut = cut; 
				for (j=0; j<graph->V; j++) {
					newFreeList[j].gain = freeList[j].gain;
					newFreeList[j].partition = freeList[j].partition;
					newFreeList[j].locked = 0;//freeList[j].locked;
				}
			}
			gainCell();
			
		}
		for (j=0; j<graph->V; j++) {
			freeList[j].gain = newFreeList[j].gain;
			freeList[j].partition = newFreeList[j].partition;
			freeList[j].locked =0;// newFreeList[j].locked;
		}
		gainCell();
	}while(cut != minCut);
	
	printf("Size of Left %d and Size of Right %d\n", sizeL, sizeR);
	printf("Min Cut is %d\n", minCut);
	
	writeResults(); // write final partition to file
	
	fclose(fp);
    	return 0;
}
Ejemplo n.º 23
0
//Gestionnaire de signal
void sigHandler(int arg)
{
    writeResults();
    dispose();
    exit(EXIT_SUCCESS);
}
Ejemplo n.º 24
0
int main (int argc, const char * argv[]){

    struct timeval start, end;
    gettimeofday(&start, NULL);

    // general parameters
    size_t maxSeqLen = 50000;
    int seqType = Sequence::AMINO_ACIDS;

    // parameter for the prefiltering
    int kmerSize = 6;
    int alphabetSize = 21;
    size_t maxResListLen = 100;
    int split = 0;
    int skip = 0;
    bool aaBiasCorrection = true;
    float zscoreThr = 50.0f;
    float sensitivity = 4.0;

    // parameters for the alignment
    double evalThr = 0.001;
    double covThr = 0.8;
    int maxAlnNum = 10;

    std::string lastSeqDB = "";
    std::string currentSeqDB = "";
    std::string cluDB = ""; 
    std::string outDB = "";
    std::string tmpDir = "";

    // get the path of the scoring matrix
    char* mmdir = getenv ("MMDIR");
    if (mmdir == 0){
        std::cerr << "Please set the environment variable $MMDIR to your MMSEQS installation directory.\n";
        exit(1);
    }
    std::string scoringMatrixFile(mmdir);
    scoringMatrixFile = scoringMatrixFile + "/data/blosum62.out";

    parseArgs(argc, argv, &lastSeqDB, &currentSeqDB, &cluDB, &outDB, &tmpDir, &scoringMatrixFile, &maxSeqLen);

    std::string lastSeqDBIndex = lastSeqDB + ".index";
    std::string currentSeqDBIndex = currentSeqDB + ".index";
    std::string cluDBIndex = cluDB + ".index";
    std::string outDBIndex = outDB + ".index";

    std::list<std::string>* tmpFiles = new std::list<std::string>();
    std::string AIndex = tmpDir + "/A.index";
    std::string BIndex = tmpDir + "/B.index";
    tmpFiles->push_back(AIndex);
    tmpFiles->push_back(BIndex);

    std::string Brest_indexFile = tmpDir + "/Brest.index";
    tmpFiles->push_back(Brest_indexFile);
    
    std::string BB_clu = tmpDir + "/BB_clu";
    std::string BB_clu_index = BB_clu + ".index";
    tmpFiles->push_back(BB_clu);
    tmpFiles->push_back(BB_clu_index);
    
    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    std::cout << "///////                   Init                             /////////////\n";
    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    // extract three indexes:
    // - A: last database version without deleted sequences
    // - B: sequences which are new in the database
    writeIndexes(AIndex, BIndex, lastSeqDBIndex, currentSeqDBIndex);


    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    std::cout << "///////            Calculating B->A scores                 /////////////\n";
    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    // calculate score for the updating
    // B->A scores
    std::string BA_base = runScoresCalculation(currentSeqDB, BIndex,
            currentSeqDB, AIndex,
            tmpDir,
            scoringMatrixFile, maxSeqLen, seqType,
            kmerSize, alphabetSize, maxResListLen, split, skip, aaBiasCorrection, zscoreThr, sensitivity,
            evalThr, covThr, maxAlnNum, "BA", tmpFiles);

    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    std::cout << "///////      Adding sequences to existing clusters         /////////////\n";
    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    // update the clustering
    DBReader* currSeqDbr = new DBReader(currentSeqDB.c_str(), currentSeqDBIndex.c_str());
    currSeqDbr->open(DBReader::NOSORT);

    // data structures for the clustering
    int seqDBSize = currSeqDbr->getSize();
    unsigned int* id2rep = new unsigned int[seqDBSize];
    char** rep2cluName = new char*[seqDBSize];
    for (int i = 0; i < seqDBSize; i++)
        rep2cluName[i] = new char[FFINDEX_MAX_ENTRY_NAME_LENTH];
    cluster_t* clusters = new cluster_t[seqDBSize];
    for (int i = 0; i < seqDBSize; i++){
        clusters[i].clu_size = 0;
        clusters[i].first = 0;
        clusters[i].last = 0;
    }

    std::cout << "Read the existing clustering...\n";
    // Read the existing clustering
    readClustering(currSeqDbr, cluDB, id2rep, rep2cluName, clusters);

    std::cout << "Append new sequences to the existing clustering...\n";
    // append sequences from the new database to the existing clustering based on the B->A alignment scores
    // write sequences without a match to a separate index (they will be clustered separately)
    appendToClustering(currSeqDbr, BIndex, BA_base, id2rep, clusters, Brest_indexFile);

    if (seqsWithoutMatches > 0){
        std::cout << "////////////////////////////////////////////////////////////////////////\n";
        std::cout << "///////            Calculating B->B scores                 /////////////\n";
        std::cout << "////////////////////////////////////////////////////////////////////////\n";
        // B->B scores
        std::string BB_base = runScoresCalculation(currentSeqDB, Brest_indexFile, 
                currentSeqDB, Brest_indexFile,
                tmpDir,
                scoringMatrixFile, maxSeqLen, seqType,
                kmerSize, alphabetSize, maxResListLen, split, skip, aaBiasCorrection, zscoreThr, sensitivity,
                evalThr, covThr, maxAlnNum, "BB", tmpFiles);

        std::cout << "////////////////////////////////////////////////////////////////////////\n";
        std::cout << "///////             Appending new clusters                 /////////////\n";
        std::cout << "////////////////////////////////////////////////////////////////////////\n";
        std::cout << "Cluster new sequences without a match to the existing clusters...\n";
        // cluster sequences without a match to the existing clusters separately
        // use the index generated in the previous step
        Clustering* clu = new Clustering(currentSeqDB, currentSeqDBIndex,
                BB_base, BB_base + ".index",
                BB_clu, BB_clu_index,
                0.0, 0, maxResListLen);
        clu->run(Clustering::SET_COVER); 

        std::cout << "Append generated clusters to the complete clustering...\n";
        // append B->B clusters to the clustering
        newClus = readClustering(currSeqDbr, BB_clu, id2rep, rep2cluName, clusters);
    }

    // write new clustering
    std::cout << "Write clustering results...\n";
    writeResults(clusters, rep2cluName, currSeqDbr, seqDBSize, outDB);
    std::cout << "done.\n";

    currSeqDbr->close();

    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    std::cout << "///////                   Statistics                            ////////\n";
    std::cout << "////////////////////////////////////////////////////////////////////////\n";
    std::cout << "\nPrevios database version: " << oldDBSize << " entries.\n";
    std::cout << "New database vesion     : " << newDBSize << " entries.\n";
    std::cout << deletedSeqs << " entries were deleted,\n";
    std::cout << newSeqs << " entries are new,\n";
    std::cout << sharedSeqs << " entries are shared.\n\n";

    std::cout << seqsWithMatches << " new sequences had matches to the previous database version.\n";
    std::cout << "Remaining " << seqsWithoutMatches << " were grouped into " << newClus << " new clusters.\n";
 
    gettimeofday(&end, NULL);
    int sec = end.tv_sec - start.tv_sec;
    std::cout << "\nTime for updating: " << (sec / 3600) << " h " << (sec % 3600 / 60) << " m " << (sec % 60) << "s\n\n";

    deleteTmpFiles(tmpFiles);
    delete tmpFiles;

}