Myagkij в 03:59, 27 августа 2023

2023-08-27T03:59:28Z

@@ Строка 1: / Строка 1: @@
 {{Processing панель перехода}}
 {{Перевод от Сubewriter}}
 {{Myagkij-редактор}}
 =Описание<ref>[https://processing.org/examples/flocking.html processing.org - Flocking by Daniel Shiffman. ]</ref>=
@@ Строка 533: / Строка 530: @@
 <references />
 {{Навигационная таблица/Портал/Processing}}

EducationBot в 08:01, 20 мая 2023

2023-05-20T08:01:43Z

← Предыдущая версия		Версия от 12:01, 20 мая 2023
Строка 4:		Строка 4:
	{{Myagkij-редактор}}		{{Myagkij-редактор}}

	~~{{Черновик}}~~

	=Описание<ref>[https://processing.org/examples/flocking.html processing.org - Flocking by Daniel Shiffman. ]</ref>=		=Описание<ref>[https://processing.org/examples/flocking.html processing.org - Flocking by Daniel Shiffman. ]</ref>=
Строка 250:		Строка 250:
	}}		}}

	<syntaxhighlight lang="c" line="GESHI_NORMAL_LINE_NUMBERS\|GESHI_FANCY_LINE_NUMBERS~~" enclose="div~~">		<syntaxhighlight lang="c" line="GESHI_NORMAL_LINE_NUMBERS\|GESHI_FANCY_LINE_NUMBERS">
	Flock flock;		Flock flock;

Строка 549:		Строка 549:
	\|Высота логотипа издателя для schemaNewsArticle=45		\|Высота логотипа издателя для schemaNewsArticle=45
	}}		}}
	{{Навигационная таблица/~~Справочник языка Processing}}~~		{{Навигационная таблица/Портал/Processing}}
	~~{{Навигационная таблица~~/Processing~~/Примеры}}~~
	~~{{Навигационная таблица/Телепорт~~}}

Myagkij: /* Внешние ссылки */

2022-05-07T04:21:54Z

Внешние ссылки

← Предыдущая версия		Версия от 08:21, 7 мая 2022
Строка 551:		Строка 551:
	{{Навигационная таблица/Справочник языка Processing}}		{{Навигационная таблица/Справочник языка Processing}}
	{{Навигационная таблица/Processing/Примеры}}		{{Навигационная таблица/Processing/Примеры}}
			{{Навигационная таблица/Телепорт}}

Myagkij в 15:38, 3 августа 2018

2018-08-03T15:38:21Z

Новая страница

{{Processing панель перехода}}

{{Перевод от Сubewriter}}
{{Myagkij-редактор}}

{{Черновик}}

=Описание<ref>[https://processing.org/examples/flocking.html processing.org - Flocking by Daniel Shiffman. ]</ref>=

Реализация в Processing программы Крейга Рейнольдса «Boids», симулирующей стайное поведение птиц. Поведение каждой «птицы» регулируется 3 правилами – уклонения, выравнивания и целостности.

Кликните мышкой по экрану, чтобы добавить новую «птицу».

==Пример==

{{5pjs
|Код=
<html>
/**
* Flocking
* by Daniel Shiffman.
*
* An implementation of Craig Reynold's Boids program to simulate
* the flocking behavior of birds. Each boid steers itself based on
* rules of avoidance, alignment, and coherence.
*
* Click the mouse to add a new boid.
*/

var flock;

function setup() {
var canvas = createCanvas(640, 360);
canvas.parent("p5container");
flock = new Flock();
// Add an initial set of boids into the system
for (var i = 0; i < 150; i++) {
flock.addBoid(new Boid(width/2,height/2));
}
}

function draw() {
background(50);
flock.run();
}

// Add a new boid into the System
function mousePressed() {
flock.addBoid(new Boid(mouseX,mouseY));
}

// The Nature of Code
// Daniel Shiffman
// http://natureofcode.com

// Boid class
// Methods for Separation, Cohesion, Alignment added

function Boid(x,y) {
this.acceleration = createVector(0,0);
this.velocity = createVector(random(-1,1),random(-1,1));
this.position = createVector(x,y);
this.r = 2.0;
this.maxspeed = 2; // Maximum speed
this.maxforce = 0.03; // Maximum steering force

this.run = function(boids) {
this.flock(boids);
this.update();
this.borders();
this.render();
}

this.applyForce = function(force) {
// We could add mass here if we want A = F / M
this.acceleration.add(force);
}

// We accumulate a new acceleration each time based on three rules
this.flock = function(boids) {
var sep = this.separate(boids); // Separation
var ali = this.align(boids); // Alignment
var coh = this.cohesion(boids); // Cohesion
// Arbitrarily weight these forces
sep.mult(1.5);
ali.mult(1.0);
coh.mult(1.0);
// Add the force vectors to acceleration
this.applyForce(sep);
this.applyForce(ali);
this.applyForce(coh);
}

// Method to update location
this.update = function() {
// Update velocity
this.velocity.add(this.acceleration);
// Limit speed
this.velocity.limit(this.maxspeed);
this.position.add(this.velocity);
// Reset accelertion to 0 each cycle
this.acceleration.mult(0);
}

// A method that calculates and applies a steering force towards a target
// STEER = DESIRED MINUS VELOCITY
this.seek = function(target) {
var desired = p5.Vector.sub(target,this.position); // A vector pointing from the location to the target
// Normalize desired and scale to maximum speed
desired.normalize();
desired.mult(this.maxspeed);
// Steering = Desired minus Velocity
var steer = p5.Vector.sub(desired,this.velocity);
steer.limit(this.maxforce); // Limit to maximum steering force
return steer;
}

this.render = function() {
// Draw a triangle rotated in the direction of velocity
var theta = this.velocity.heading() + radians(90);
fill(200,100);
stroke(255);
push();
translate(this.position.x,this.position.y);
rotate(theta);
beginShape();
vertex(0, -this.r*2);
vertex(-this.r, this.r*2);
vertex(this.r, this.r*2);
endShape(CLOSE);
pop();
}

// Wraparound
this.borders = function() {
if (this.position.x < -this.r) this.position.x = width +this.r;
if (this.position.y < -this.r) this.position.y = height+this.r;
if (this.position.x > width +this.r) this.position.x = -this.r;
if (this.position.y > height+this.r) this.position.y = -this.r;
}

// Separation
// Method checks for nearby boids and steers away
this.separate = function(boids) {
var desiredseparation = 25.0;
var steer = createVector(0,0);
var count = 0;
// For every boid in the system, check if it's too close
for (var i = 0; i < boids.length; i++) {
var d = p5.Vector.dist(this.position,boids[i].position);
// If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
if ((d > 0) && (d < desiredseparation)) {
// Calculate vector pointing away from neighbor
var diff = p5.Vector.sub(this.position,boids[i].position);
diff.normalize();
diff.div(d); // Weight by distance
steer.add(diff);
count++; // Keep track of how many
}
}
// Average -- divide by how many
if (count > 0) {
steer.div(count);
}

// As long as the vector is greater than 0
if (steer.mag() > 0) {
// Implement Reynolds: Steering = Desired - Velocity
steer.normalize();
steer.mult(this.maxspeed);
steer.sub(this.velocity);
steer.limit(this.maxforce);
}
return steer;
}

// Alignment
// For every nearby boid in the system, calculate the average velocity
this.align = function(boids) {
var neighbordist = 50;
var sum = createVector(0,0);
var count = 0;
for (var i = 0; i < boids.length; i++) {
var d = p5.Vector.dist(this.position,boids[i].position);
if ((d > 0) && (d < neighbordist)) {
sum.add(boids[i].velocity);
count++;
}
}
if (count > 0) {
sum.div(count);
sum.normalize();
sum.mult(this.maxspeed);
var steer = p5.Vector.sub(sum,this.velocity);
steer.limit(this.maxforce);
return steer;
} else {
return createVector(0,0);
}
}

// Cohesion
// For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
this.cohesion = function(boids) {
var neighbordist = 50;
var sum = createVector(0,0); // Start with empty vector to accumulate all locations
var count = 0;
for (var i = 0; i < boids.length; i++) {
var d = p5.Vector.dist(this.position,boids[i].position);
if ((d > 0) && (d < neighbordist)) {
sum.add(boids[i].position); // Add location
count++;
}
}
if (count > 0) {
sum.div(count);
return this.seek(sum); // Steer towards the location
} else {
return createVector(0,0);
}
}
}

// The Flock (a list of Boid objects)

function Flock() {
// An array for all the boids
this.boids = []; // Initialize the array

this.run = function() {
for (var i = 0; i < this.boids.length; i++) {
this.boids[i].run(this.boids); // Passing the entire list of boids to each boid individually
}
}

this.addBoid = function(b) {
this.boids.push(b);
}
}

</html>
}}

<syntaxhighlight lang="c" line="GESHI_NORMAL_LINE_NUMBERS|GESHI_FANCY_LINE_NUMBERS" enclose="div">
Flock flock;

void setup() {
size(640, 360);
flock = new Flock();
// добавляем в систему начальную стаю «птиц»:
for (int i = 0; i < 150; i++) {
flock.addBoid(new Boid(width/2,height/2));
}
}

void draw() {
background(50);
flock.run();
}

// добавляем в систему новую «птицу»:
void mousePressed() {
flock.addBoid(new Boid(mouseX,mouseY));
}

// объект «Flock» (список объектов «Boid»)

class Flock {
ArrayList<Boid> boids; // объект ArrayList для хранения всех «птиц»

Flock() {
boids = new ArrayList<Boid>(); // инициализируем «boids»
}

void run() {
for (Boid b : boids) {
b.run(boids); // прогоняем все объекты «Boid»
// в списке «boids» друг через друга
}
}

void addBoid(Boid b) {
boids.add(b);
}

}

// класс «Boid»

class Boid {

PVector position;
PVector velocity;
PVector acceleration;
float r;
float maxforce; // максимальная сила поворота
float maxspeed; // максимальная скорость

Boid(float x, float y) {
acceleration = new PVector(0, 0);

// это новый метод для объекта «PVector»,
// еще не добавленный в JavaScript:
// velocity = PVector.random2D();

// временно воспользуемся этим кодом,
// чтобы этот скетч можно было запустить в JavaScript:
float angle = random(TWO_PI);
velocity = new PVector(cos(angle), sin(angle));

position = new PVector(x, y);
r = 2.0;
maxspeed = 2;
maxforce = 0.03;
}

void run(ArrayList<Boid> boids) {
flock(boids);
update();
borders();
render();
}

void applyForce(PVector force) {
// здесь, если необходимо, можно добавить массу (A = F / M):
acceleration.add(force);
}

// рассчитываем ускорение на основе 3 правил:
void flock(ArrayList<Boid> boids) {
PVector sep = separate(boids); // уклонение
PVector ali = align(boids); // выравнивание
PVector coh = cohesion(boids); // целостность
// задаем всем этим силам некоторые значения:
sep.mult(1.5);
ali.mult(1.0);
coh.mult(1.0);
// применяем к ускорению все три вектора силы:
applyForce(sep);
applyForce(ali);
applyForce(coh);
}

// функция для обновления данных о позиции:
void update() {
// обновляем скорость:
velocity.add(acceleration);
// ограничиваем скорость:
velocity.limit(maxspeed);
position.add(velocity);
// на каждом цикле сбрасываем скорость до «0»:
acceleration.mult(0);
}

// функция для расчета и применения силы поворота в сторону цели
// (сила поворота = вектор «desired» - вектор «velocity»):
PVector seek(PVector target) {
// вектор, указывающий от позиции к цели:
PVector desired = PVector.sub(target, position);
// масштабируем «desired» к максимальной скорости:
desired.normalize();
desired.mult(maxspeed);

// две строчки выше можно сократить с помощью
// нового метода setMag() для объекта PVector,
// но мы не будем его использовать,
// пока его не начнет поддерживать Processing.js:
// desired.setMag(maxspeed);

// сила поворота = вектор «desired» - вектор «velocity»:
PVector steer = PVector.sub(desired, velocity);
steer.limit(maxforce); // ограничиваем до
// максимальной силы поворота:
return steer;
}

void render() {
// рисуем треугольник, поворачивающийся
// в направлении вектора «velocity»:
float theta = velocity.heading2D() + radians(90);
// метод heading2D() выше – это теперь heading(),
// но я решил оставить старый синтаксис,
// пока Processing.js не начнет поддерживать новый

fill(200, 100);
stroke(255);
pushMatrix();
translate(position.x, position.y);
rotate(theta);
beginShape(TRIANGLES);
vertex(0, -r*2);
vertex(-r, r*2);
vertex(r, r*2);
endShape();
popMatrix();
}

// делаем так, чтобы «птицы», вылетая за пределы экрана,
// появлялись в противоположной части экрана:
void borders() {
if (position.x < -r) position.x = width+r;
if (position.y < -r) position.y = height+r;
if (position.x > width+r) position.x = -r;
if (position.y > height+r) position.y = -r;
}

// Правило уклонения.
// Эта функция проверяет, есть ли рядом другие «птицы»,
// и если есть, то заставляет «птицу» уклониться от соседа:
PVector separate (ArrayList<Boid> boids) {
float desiredseparation = 25.0f;
PVector steer = new PVector(0, 0, 0);
int count = 0;
// проверяем каждую «птицу» в системе на предмет того,
// находится ли она близко к другой «птице»:
for (Boid other : boids) {
float d = PVector.dist(position, other.position);
// если дистанция больше «0» (это сама «птица»)
// и меньше значения в «desiredseparation»...
if ((d > 0) && (d < desiredseparation)) {
// рассчитываем вектор для уклонения от соседа:
PVector diff = PVector.sub(position, other.position);
diff.normalize();
diff.div(d); // подгоняем к дистанции между «птицами»
steer.add(diff);
count++; // отслеживаем, сколько раз
// выполнялось это условие
}
}
// Среднее значение – делим на то,
// сколько раз выполнялось это условие:
if (count > 0) {
steer.div((float)count);
}

// если длина вектора больше «0»...
if (steer.mag() > 0) {
// первые две строчки кода ниже
// можно заменить на новый метод setMag() для PVector;
// здесь мы его использовать не будем,
// пока его не начнет поддерживать Processing.js:
// steer.setMag(maxspeed);

// используем правило Рейнольдса:
// (сила поворота = вектор «desired» - вектор «velocity»):
steer.normalize();
steer.mult(maxspeed);
steer.sub(velocity);
steer.limit(maxforce);
}
return steer;
}

// Правило выравнивания.
// Рассчитываем среднюю скорость
// для каждой соседней «птицы» в системе:
PVector align (ArrayList<Boid> boids) {
float neighbordist = 50;
PVector sum = new PVector(0, 0);
int count = 0;
for (Boid other : boids) {
float d = PVector.dist(position, other.position);
if ((d > 0) && (d < neighbordist)) {
sum.add(other.velocity);
count++;
}
}
if (count > 0) {
sum.div((float)count);
// первые две строчки кода ниже
// можно заменить на новый метод setMag() для PVector;
// здесь мы его использовать не будем,
// пока его не начнет поддерживать Processing.js:
// sum.setMag(maxspeed);

// используем правило Рейнольдса:
// (сила поворота = вектор «desired» - вектор «velocity»):
sum.normalize();
sum.mult(maxspeed);
PVector steer = PVector.sub(sum, velocity);
steer.limit(maxforce);
return steer;
}
else {
return new PVector(0, 0);
}
}

// Правило целостности.
// Рассчитываем вектор поворота
// в сторону средней (то есть центральной) позиции
// всех соседних «птиц»:
PVector cohesion (ArrayList<Boid> boids) {
float neighbordist = 50;
PVector sum = new PVector(0, 0); // начинаем с пустого вектора
// для сложения всех позиций
int count = 0;
for (Boid other : boids) {
float d = PVector.dist(position, other.position);
if ((d > 0) && (d < neighbordist)) {
sum.add(other.position); // добавляем позицию
count++;
}
}
if (count > 0) {
sum.div(count);
return seek(sum); // поворачиваем в сторону позиции
}
else {
return new PVector(0, 0);
}
}
}
</syntaxhighlight>

=См.также=

=Внешние ссылки=

<references />

{{SEO
|Заголовок статьи=Processing: Стая / Онлайн справочник - wikihandbk.com
|Ключевые слова=processing,Стая в processing, пример Стая, пример Стая в ArrayList в processing
|Описание статьи=
|Изображение статьи для Open Graph=
|Адрес страницы для schemaNewsArticle=<nowiki>http://wikihandbk.com/wiki/Processing:Примеры/Стая</nowiki>
|Изображение статьи для schemaNewsArticle=<nowiki></nowiki>
|Высота изображения статьи для schemaNewsArticle=
|Ширина изображения статьи для schemaNewsArticle=
|Дата публикации для schemaNewsArticle=2018-08-03
|Автор=Мякишев Е.А.
|Издатель=myagkij
|Логотип издателя для schemaNewsArticle=<nowiki>http://wikihandbk.com/ruwiki/images/6/61/Tech_geek_logo_1x.jpg</nowiki>
|Ширина логотипа издателя для schemaNewsArticle=60
|Высота логотипа издателя для schemaNewsArticle=45
}}
{{Навигационная таблица/Справочник языка Processing}}
{{Навигационная таблица/Processing/Примеры}}

Processing:Примеры/Стая - История изменений

Myagkij в 03:59, 27 августа 2023

EducationBot в 08:01, 20 мая 2023

Myagkij: /* Внешние ссылки */

Myagkij в 15:38, 3 августа 2018