/** Tworzenie czasteczki.. */
void SnowEmitter::createNewParticle(Window* _window) {
for (usint i = 0; i < getIntRandom(2, (int) (50 * (50.f / (float) delay)));
++i) {
float angle = getIntRandom<int>(20, 80);
float speed = 1.f;
Vector<float> wind(
cos(TO_RAD(angle)) * speed,
sin(TO_RAD(angle)) * speed);
Particle part(
Vector<float>(x, y),
getIntRandom(6, 14),
getIntRandom(50, 100),
oglWrapper::WHITE);
part.velocity = wind;
part.angle = angle;
part.velocity.y += getIntRandom(150, 350) / 150;
part.pos.x = x + getIntRandom(-100, (int) w + 100);
particles.push_back(part);
}
}
/** \brief This constructor is used when a species is randomly created (!!! NOT USED NOW)
@version 0.1 (8 parameters)
@param tmpID species identificator
@param tmpSequence species sequence (e.g. ABABAABABA)
@param tmpAmount species initial amount of molecules
@param acs_double tmpDiffusionEnh Diffusione enhancement parameter
@param acs_double tmpPrecipitationEnh Precipitation Enhancement parameters
@param acs_double tmpComplexProb Probability to be a complex
@param acs_double tmpMaxComplexDegKinetic max complex degradation constant
@param MTRand& tmp_RandomGenerator random generator
*/
species::species(acs_longInt tmpID, string tmpSequence, acs_longInt tmpAmount, acs_double tmpDiffusionEnh,
acs_int tmpSoluble, acs_double tmpComplexProb, acs_double tmpMaxComplexDegKinetic,
MTRand& tmp_RandomGenerator, acs_double tmpVolume, acs_double tmpK_phospho, acs_int tmpEnergizable, acs_double tmpAlpha)
{
cout << "four" << endl;
id = tmpID;
sequence = tmpSequence;
amount = tmpAmount;
numToConc(tmpVolume);
chargedMols = 0;
age = 0;
reborns = 0;
diffusionEnh =tmpDiffusionEnh;
soluble = tmpSoluble;
// RANDOM SELECTION BETWEEN SPECIES AND COMPLEX ACCORDING TO THE COMPLEX CREATION PROBABILITY
acs_double dice = tmp_RandomGenerator();
if(dice <= tmpComplexProb) //COMPLEX
{
complexDegradationEnh = getDoubleRandom(0.0, tmpMaxComplexDegKinetic, tmp_RandomGenerator);
complexCuttingPoint = getIntRandom(2, sequence.length(), tmp_RandomGenerator) - 1;
}else{ //SPECIES
complexDegradationEnh = 0;
complexCuttingPoint = 0;
}
evaluated = 0;
K_phospho = tmpK_phospho;
energizable = tmpEnergizable;
concentrationFixed = false;
firstConcentration = 0; // 0 because the species is created during on run
lastSpeciesEvaluated = 0;
alpha = tmpAlpha;
}
int main(int, char const**)
{
// Create the main window
sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
/**
* Bruit de base
*/
sf::Image imagebruitRandom;
sf::Texture textureBruitRandom;
sf::Sprite spriteBruitRandom;
imagebruitRandom.create(800, 600);
for(int i = 0; i < 800; i++)
for(int j = 0; j < 600; j++)
if(getIntRandom(0,1) == 1)
imagebruitRandom.setPixel(i,j, sf::Color::White);
textureBruitRandom.loadFromImage(imagebruitRandom);
spriteBruitRandom.setTexture(textureBruitRandom);
/*-----------------------*/
/**
* Le background
*/
sf::Image backgroundMouvement = imagebruitRandom;
sf::Texture textureBackgroundMouvement;
sf::Sprite spriteBackgroundMouvement;
/*------------------------*/
/**
* Le texte
*/
sf::Text texteEcrit;
sf::Font fontTexte;
fontTexte.loadFromFile("/Users/nicolasserf/Desktop/ProjetPersonnel/monPremierBruit/monPremierBruit/sansation.ttf");
texteEcrit.setCharacterSize(100);
texteEcrit.setColor(sf::Color::White);
texteEcrit.setString("SALOPE");
texteEcrit.setFont(fontTexte);
texteEcrit.setPosition(250, 300);
/*-------------------------*/
/**
* Texture texte "bruité"
*/
sf::RenderTexture texteBruite;
texteBruite.create(800, 600);
texteBruite.draw(texteEcrit);
texteBruite.display();
texteBruite.draw(spriteBruitRandom, sf::BlendMultiply);
texteBruite.display();
sf::Sprite spriteTexteBruite;
spriteTexteBruite.setTexture(texteBruite.getTexture());
/*-------------------------*/
/**
* Texture background "bruité"
*/
texteEcrit.setColor(sf::Color::Black); //on va écrire en noir sur fond blanc
sf::RenderTexture backgroundBruite;
backgroundBruite.create(800, 600);
backgroundBruite.clear(sf::Color::White); //Fond blanc
backgroundBruite.draw(texteEcrit);
backgroundBruite.display();
/*------------------------*/
/**
* Réunion du texte bruité et du background bruité
*/
sf::Sprite regroupe;
bool stop = true;
while (window.isOpen())
{
if(stop)
{
backgroundMouvement = rotation(backgroundMouvement);
textureBackgroundMouvement.loadFromImage(backgroundMouvement);
spriteBackgroundMouvement.setTexture(textureBackgroundMouvement);
backgroundBruite.draw(spriteBackgroundMouvement, sf::BlendMultiply);
backgroundBruite.display();
regroupe.setTexture(backgroundBruite.getTexture());
backgroundBruite.draw(spriteTexteBruite, sf::BlendAdd);
backgroundBruite.display();
regroupe.setTexture(backgroundBruite.getTexture());
}
sf::Event event;
while (window.pollEvent(event))
{
// Close window: exit
if (event.type == sf::Event::Closed) {
window.close();
}
// Escape pressed: exit
if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
window.close();
}
if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::A) {
if(stop == false)
stop = true;
else
stop = false;
}
}
// Clear screen
window.clear();
//window.draw(spriteTexteBruite);
window.draw(regroupe);
// Update the window
window.display();
if(stop){
backgroundBruite.clear(sf::Color::White);
backgroundBruite.draw(texteEcrit);
backgroundBruite.display();
}
}
return EXIT_SUCCESS;
}
/**
* 学習処理
* const char * path:保存先フォルダ
*/
int learningNeuralNetworkPP(const char * path) {
if (state < 1) {
printf("Not create neural network.\n");
return -1;
}
/*処理開始*/
start_time = gettimeofday_sec();
int i, j;
x = (double *) malloc(sizeof(double) * input.pattern * input.num);
d = (double *) malloc(sizeof(double) * input.pattern * output.num);
/*ログ用変数*/
int log_count = 0;/*ログをテキストに書きだした回数*/
int save_count = 0;/*ログを書きだすべきかどうか(0ならば書き出し、それ以外は無視)*/
/*ログユニットのメモリを確保(隠れ層)*/
logerH.num = getIntRandom(0, hidden[0].num - 1);
logerH.bias = (double *) malloc(sizeof(double) * array_size);
logerH.d = (double *) malloc(sizeof(double) * array_size);
logerH.w = (double *) malloc(sizeof(double) * input.num * array_size);
logerH.z = (double *) malloc(sizeof(double) * array_size);
/*ログユニットのメモリを確保(出力層)*/
logerO.num = getIntRandom(0, output.num - 1);
logerO.bias = (double *) malloc(sizeof(double) * array_size);
logerO.d = (double *) malloc(sizeof(double) * array_size);
logerO.w = (double *) malloc(sizeof(double) * hidden[numLayer - 3].num * array_size);
logerO.z = (double *) malloc(sizeof(double) * array_size);
/*ニューラルネットワークの処理*/
int num = 0;/*入力するパターン番号*/
int start;/*読み込み開始ライン*/
for (i = 0; i < times; i++) {
printf("learning times %d-th.\n", i);
/*ログ処理*/
if (i % logFre == 0) {
/*データをログに格納*/
logerH.bias[save_count] = hidden[0].bias[logerH.num];
logerH.d[save_count] = 0.0;
logerH.z[save_count] = hidden[0].z[logerH.num];
for (j = 0; j < input.num; j++) {
logerH.w[input.num * save_count + j] = hidden[0].w[input.num * logerH.num + j];
}
logerO.bias[save_count] = output.bias[logerO.num];
logerO.d[save_count] = input.d[output.num * num + logerO.num];
logerO.z[save_count] = output.z[logerO.num];
for (j = 0; j < hidden[numLayer - 3].num; j++) {
logerO.w[hidden[numLayer - 3].num * save_count + j] =
output.w[hidden[numLayer - 3].num * logerO.num + j];
}
save_count++;
if (save_count == array_size && i != 0) {
/*書き出し処理*/
saveLogUnit(path, "hidden.csv", array_size, &logerH, log_count * array_size, array_size, input.num);
saveLogUnit(path, "output.csv", array_size, &logerO, log_count * array_size, array_size,
hidden[numLayer - 3].num);
log_count++;
save_count = 0;
}
}
/*画像の学習が一定数終わったら新しい画像へ入れ替え*/
if (data_type == 1 && array_size < NUM_IMAGES && i != 0 && i % (array_size / 2) == 0) {
loadLineReset();
DataSetTrainMNIST(input.pattern, x, d);
setInput(output.num, &input, x, d);
} else if (data_type == 0 && array_size < image_list.imageNum && i != 0 && i % (array_size / 2) == 0) {
start = getIntRandom(0, image_list.imageNum - array_size);
inputToImageData(&image_list, start, input.pattern, x, d);
setInput(output.num, &input, x, d);
}
/*入力値を決定*/
num = getIntRandom(0, input.pattern - 1);
/*dropoutの判定*/
if (dropout > 0) {
setInputLayerDropout(&input);
for (j = 0; j < numLayer - 2; j++) {
setDropout(&hidden[j]);
}
}
/*出力処理(中間層)*/
for (j = 0; j < numLayer - 2; j++) {
if (j > 0) {
hiddenToOtherLayer(&hidden[j - 1], &hidden[j], 1.0);
} else {
inputToHiddenLayer(num, &input, &hidden[j], 1.0, 1.0);
}
}
/*出力処理(出力層)*/
hiddenToOtherLayer(&hidden[numLayer - 3], &output, 1.0);
/*学習処理(出力層)*/
learningOutputLayer(num, &input, &hidden[numLayer - 3], &output);
/*学習処理(中間層)*/
for (j = (numLayer - 3); j > -1; j--) {
if (numLayer == 3) {
learningFirstHiddenLayer(num, &input, &hidden[j], &output);
} else if (j == (numLayer - 3)) {
learningHiddenLayer(&hidden[j - 1], &hidden[j], &output);
} else if (j > 0) {
learningHiddenLayer(&hidden[j - 1], &hidden[j], &hidden[j + 1]);
} else {
learningFirstHiddenLayer(num, &input, &hidden[j], &hidden[j + 1]);
}
}
/*dropoutを初期化*/
if (dropout > 0) {
resetInputLayerDropout(&input);
for (j = 0; j < numLayer - 2; j++) {
resetDropout(&hidden[j]);
}
}
}
/*残りのログデータを保存*/
if (save_count != 0 || times == 1) {
saveLogUnit(path, "hidden.csv", array_size, &logerH, log_count * array_size, save_count, input.num);
saveLogUnit(path, "output.csv", array_size, &logerO, log_count * array_size, save_count,
hidden[numLayer - 3].num);
}
/*ログユニットのメモリを解放(隠れ層)*/
free(logerH.bias);
free(logerH.d);
free(logerH.w);
free(logerH.z);
/*ログユニットのメモリを解放(出力層)*/
free(logerO.bias);
free(logerO.d);
free(logerO.w);
free(logerO.z);
/*ニューラルネットワークを保存*/
printf("->Writing Neural Network\n");
if (saveNeuralNetwork(path, numLayer, &input, &hidden, &output, dropout) < 0) {
printf("ERROR:Not writed save data in %s.\n", path);
/*エンターを押して終了を後で追加*/
return -1;
}
/*処理終了*/
free(x);
free(d);
end_time = gettimeofday_sec();
return 1;
}
