# data[].attributes.body
int numObjects = 90; // 물체의 개수를 3배로 늘림 (기존 30개 x 3)

float[] objectX = new float[numObjects];
float[] objectY = new float[numObjects];
float[] objectSize = new float[numObjects];
color[] objectColor = new color[numObjects];

void setup() {
size(1080, 1080);
noStroke(); // 윤곽선 제거
ellipseMode(CENTER);

// 물체들 초기화
for (int i = 0; i < numObjects; i++) {
objectX[i] = random(width);
objectY[i] = random(height);
objectSize[i] = random(20, 50);
objectColor[i] = color(random(255), random(255), random(255), 150); // 알파 값(투명도) 추가
}
}

void draw() {
background(0); // 배경을 검은색으로 설정

// 물체들 그리기
for (int i = 0; i < numObjects; i++) {
fill(objectColor[i]);
ellipse(objectX[i], objectY[i], objectSize[i], objectSize[i]);

// 물체들 자동으로 움직이도록 위치 변화
objectX[i] += random(-2, 2);
objectY[i] += random(-2, 2);

// 화면 벗어나지 않도록 제한
objectX[i] = constrain(objectX[i], 0, width);
objectY[i] = constrain(objectY[i], 0, height);

// 색상 변화
objectColor[i] = color(random(255), random(255), random(255), 150); // 알파 값(투명도) 추가
}
saveFrame("my image_####.png");
}

# data[].attributes.headline
3차시 추상화 결과물 공유

# data[].attributes.subject
3차시 추상화 결과물 공유

# data[].attributes.body
컴퓨터 배경화면, 인스타 게시용, 카카오톡프로필 사진, 동영상 등으로 다양하게 제작해 보세요.

# data[].attributes.headline
동영상이 업로드 안되면...

# data[].attributes.subject
동영상이 업로드 안되면...

# data[].attributes.body
나눠드린 USB에 저장해 주세요.

# data[].attributes.headline
메인 페이지로 돌아가고 싶을 때

# data[].attributes.subject
메인 페이지로 돌아가고 싶을 때

# data[].attributes.body
int personX;     // 사람의 x 좌표
int personY;     // 사람의 y 좌표
int personSpeed;     // 사람의 이동 속도
int personSize;     // 사람의 크기

boolean movingLeft;     // 왼쪽으로 움직이는지 여부
boolean movingRight;    // 오른쪽으로 움직이는지 여부

void setup() {
size(800, 400);

personSize = 40;
personX = width / 2;
personY = height - personSize;
personSpeed = 5;

movingLeft = true;
movingRight = false;
}

void draw() {
background(200);

// 사람 이동
movePerson();

// 사람 그리기
drawPerson();

// 보행 신호등 그리기
drawTrafficLight();

// 보행 신호 체크
checkTrafficLight();
}

void movePerson() {
if (movingLeft && personX > personSize / 2) {
personX -= personSpeed;
} else if (movingRight && personX < width - personSize / 2) {
personX += personSpeed;
}
}

void drawPerson() {
// 몸
fill(255, 0, 0);
rect(personX - personSize / 4, personY - personSize, personSize / 2, personSize);

// 머리
fill(255);
ellipse(personX, personY - personSize * 1.5, personSize / 2, personSize / 2);

// 다리
fill(0);
rect(personX - personSize / 4, personY, personSize / 2, personSize);
}

void drawTrafficLight() {
// 신호등 기둥
fill(100);
rect(width / 2 - 10, height / 2, 20, height / 2);

// 신호등 불
fill(255, 0, 0);
ellipse(width / 2, height / 2 + 30, 30, 30);
}

void checkTrafficLight() {
if (movingLeft && personX < width / 2 - 20 && personX > width / 2 - 70) {
movingLeft = false;
movingRight = true;
} else if (movingRight && personX > width / 2 + 20 && personX < width / 2 + 70) {
movingLeft = true;
movingRight = false;
}
saveFrame("my image_####.png");
}

# data[].attributes.body
ArrayList<Fish> fishes;
int numFishes = 30;

void setup() {
size(600, 600);
fishes = new ArrayList<Fish>();

for (int i = 0; i < numFishes; i++) {
float fishSize = random(20, 50);
fishes.add(new Fish(random(width), random(height - 100), fishSize));
}
}

void draw() {
drawSky();
drawSun();
drawSea();

// 물고기들 그리기
for (Fish fish : fishes) {
fish.update();
fish.display();
}
saveFrame("my image_####.png");
}

void drawSky() {
color topColor = color(135, 206, 235); // 하늘 위쪽 색상
color horizonColor = color(249, 181, 77); // 일출/일몰 선 색상
color bottomColor = color(224, 88, 129); // 하늘 아래쪽 색상

for (int y = 0; y < height / 2; y++) {
float inter = map(y, 0, height / 2, 0, 1);
color c = lerpColor(topColor, horizonColor, inter);
stroke(c);
line(0, y, width, y);
}

for (int y = height / 2; y < height; y++) {
float inter = map(y, height / 2, height, 0, 1);
color c = lerpColor(horizonColor, bottomColor, inter);
stroke(c);
line(0, y, width, y);
}
}

float sunX, sunY; // 해의 위치
float sunRiseSpeed = 0.05; // 해가 떠오르는 속도

void drawSun() {
fill(255, 255, 0); // 노란색 해
sunX = map(millis() % 20000, 0, 20000, -200, width + 200); // 해가 동쪽에서 떠오르는 효과
sunY = height / 2 - 100 + cos(millis() * sunRiseSpeed) * 200; // 해가 곡선 형태로 떠오르는 효과
ellipse(sunX, sunY, 60, 60);
}

void drawSea() {
color waterColor = color(66, 113, 178); // 파란 바다 색상
color reflectionColor = color(224, 88, 129, 100); // 빨간색 해 반사 색상

fill(waterColor);
noStroke();
rect(0, height / 2, width, height / 2); // 바다 그리기

// 빨간색 해 반사 그리기
float reflectionY = height / 2 + 20;
fill(reflectionColor);
beginShape();
vertex(0, height);
for (float x = 0; x <= width; x += 2) {
float inter = map(x, 0, width, 0, 1);
float yOffset = cos(inter * PI) * 50;
vertex(x, reflectionY + yOffset);
}
vertex(width, height);
endShape(CLOSE);
}

class Fish {
float x, y; // 위치
float speedX, speedY; // 속도
float fishSize; // 물고기 크기

Fish(float x, float y, float size) {
this.x = x;
this.y = y;
this.fishSize = size;
this.speedX = random(-2, 2);
this.speedY = random(-1, 1);
}

void update() {
x += speedX;
y += speedY;

// 물고기가 화면 밖으로 나가면 반대쪽으로 나오도록 처리
if (x > width + fishSize) {
x = -fishSize;
y = random(height - 100);
} else if (x < -fishSize) {
x = width + fishSize;
y = random(height - 100);
}

if (y > height - 100) {
y = height - 100;
speedY *= -1; // 화면 하단에 닿으면 위로 반사
} else if (y < 0) {
y = 0;
speedY *= -1; // 화면 상단에 닿으면 아래로 반사
}
}

void display() {
// 물고기 그리기
float bodyColor = random(100, 255);
float eyeColor = random(100, 200);
fill(bodyColor, bodyColor, bodyColor);
noStroke();

// 물고기 몸통
ellipse(x, y, fishSize * 2, fishSize);

// 물고기 눈
fill(eyeColor);
float eyeX = x + fishSize * 0.6;
float eyeY = y - fishSize * 0.2;
ellipse(eyeX, eyeY, fishSize * 0.4, fishSize * 0.4);

// 물고기 꼬리
beginShape();
vertex(x - fishSize, y);
vertex(x - fishSize * 2, y + fishSize * 0.7);
vertex(x - fishSize * 2, y - fishSize * 0.7);
endShape(CLOSE);
}
}

# data[].attributes.body
void setup() {
frameRate(5);//속도

size(500, 500); // Set the size of the canvas

background(0); // Set the background color to white

}

void draw() {
// 반복적으로 랜덤한 도형 생성
for (int i = 0; i < 30; i++) {
int shapeChoice = int(random(3)); // 랜덤한 도형 선택 (0: 원, 1: 사각형, 2: 삼각형)

// 랜덤한 위치와 크기로 도형 생성
float x = random(width);
float y = random(height);
float size = random(30, 100);

// 차가운 색상 생성
float r = random(100, 180);
float g = random(100, 180);
float b = random(200, 255);
stroke(r, g, b);

// 랜덤한 도형 그리기
switch (shapeChoice) {
case 0: // 원 그리기
ellipse(x, y, size, size);
break;
case 1: // 사각형 그리기
rect(x, y, size, size);
break;
case 2: // 삼각형 그리기
float halfSize = size / 2;
float x2 = x - halfSize;
float x3 = x + halfSize;
float y2 = y + halfSize * sqrt(3);
triangle(x, y - halfSize, x2, y2, x3, y2);
break;
}
}
saveFrame("my image_####.png");}

# data[].attributes.body
int numShapes = 500;
Shape[] shapes = new Shape[numShapes];

void setup() {
size(800, 800);
for (int i = 0; i < numShapes; i++) {
shapes[i] = new Shape();
}
background(255);
}

void draw() {
background(255);
for (int i = 0; i < numShapes; i++) {
shapes[i].update();
shapes[i].display();
}
saveFrame("my image_####.png");
}

class Shape {
float x, y;
float speedX, speedY;
float size;
int shapeType;
int lifetime;
int initialLifetime;
color fillColor;

Shape() {
x = random(width);
y = random(height);
speedX = random(-2, 2);
speedY = random(-2, 2);
size = random(5, 30);
shapeType = int(random(4));
lifetime = initialLifetime = int(random(100, 300));
fillColor = color(random(200, 255), random(255), random(255), 200);
}

void update() {
x += speedX;
y += speedY;

if (x < 0 || x > width) {
speedX *= -1;
}

if (y < 0 || y > height) {
speedY *= -1;
}

lifetime--;
if (lifetime <= 0) {
resetShape();
}
}

void display() {
float alpha = map(lifetime, 0, initialLifetime, 0, 255);
fill(red(fillColor), green(fillColor), blue(fillColor), alpha);
noStroke();
switch (shapeType) {
case 0: // 점
ellipse(x, y, size, size);
break;
case 1: // 선
float length = size * 2;
float angle = atan2(speedY, speedX);
float x2 = x + cos(angle) * length;
float y2 = y + sin(angle) * length;
stroke(red(fillColor), green(fillColor), blue(fillColor), alpha);
line(x, y, x2, y2);
break;
case 2: // 면
float halfSize = size / 2;
beginShape();
vertex(x - halfSize, y - halfSize);
vertex(x + halfSize, y - halfSize);
vertex(x + halfSize, y + halfSize);
vertex(x - halfSize, y + halfSize);
endShape(CLOSE);
break;
case 3: // 도형
float angleStep = TWO_PI / 5.0;
beginShape();
for (int i = 0; i < 5; i++) {
float px = x + cos(angleStep * i) * size;
float py = y + sin(angleStep * i) * size;
vertex(px, py);
}
endShape(CLOSE);
break;
}
}

void resetShape() {
x = random(width);
y = random(height);
speedX = random(-2, 2);
speedY = random(-2, 2);
size = random(5, 20);
shapeType = int(random(4));
lifetime = initialLifetime = int(random(100, 300));
fillColor = color(random(255), random(255), random(255), 200);
}
}

# data[].attributes.body
void setup() {
size(400, 400);  // 화면 크기 설정
background(0);  // 배경색을 검은색으로 설정
}

void draw() {
// 프레임마다 실행되는 코드

// 움직이는 도형 그리기
float x = random(width);  // x 좌표 랜덤값 생성
float y = random(height);  // y 좌표 랜덤값 생성
float size = random(10, 50);  // 도형 크기 랜덤값 생성

int shapeColor = color(random(255), random(255), random(255));  // 도형 색상 랜덤값 생성 (빨강, 파랑, 보라)
fill(shapeColor);  // 도형 내부를 색상으로 채움

// 원 또는 사각형 중에서 랜덤하게 도형 그리기
if (random(1) > 0.5) {
ellipse(x, y, size, size);  // 원 그리기
} else {
rect(x, y, size, size);  // 사각형 그리기
}
}

# data[].attributes.body
int personCount = 1;
boolean isClicked = false;
int[] expressions = new int[3]; // 각 사람의 표정을 저장하는 배열

void setup() {
size(800, 600);
background(0);
randomExpressions(); // 초기 표정을 랜덤하게 설정
}

void draw() {
if (isClicked) {
background(0);
for (int i = 0; i < personCount; i++) {
float xOffset = 200 * i;
float yOffset = 0;
drawPerson(width / 2 + xOffset, height / 2 + yOffset, i);
}
updateExpressions(); // 표정을 계속해서 업데이트
} else {
// 공포스러운 느낌 요소
// 배경
fill(0);
rect(0, 0, width, height);

// 불규칙한 선들
randomLines();

// 마크 로스코 스타일 요소
// 피카소 스타일 요소
// 몬드리안 스타일 요소
drawPicassoMondrianStyle();

// 살짝 으스스한 느낌 요소
// 흰색 눈 동공
fill(255);
ellipse(width / 2 - 40, height / 2 - 20, 10, 10);
ellipse(width / 2 + 40, height / 2 - 20, 10, 10);

// 까만 입
noFill();
stroke(0);
strokeWeight(2);
arc(width / 2, height / 2 + 60, 100, 60, 0, PI);
}
saveFrame("my image_####.png");
}

void randomLines() {
stroke(255, 255, 255);
strokeWeight(2);

for (int i = 0; i < 1000; i++) {
float x1 = random(width);
float y1 = random(height);
float x2 = random(width);
float y2 = random(height);

line(x1, y1, x2, y2);
}
}

void drawPicassoMondrianStyle() {
// 피카소 스타일 요소
// 머리
fill(247, 220, 111);
ellipse(width / 2, height / 2, 200, 200);

// 눈
fill(0);
ellipse(width / 2 - 40, height / 2 - 20, 30, 30);
ellipse(width / 2 + 40, height / 2 - 20, 30, 30);

// 코
fill(255, 125, 75);
triangle(width / 2, height / 2 + 10, width / 2 - 20, height / 2 + 40, width / 2 + 20, height / 2 + 40);

// 입
noFill();
stroke(0);
strokeWeight(4);
arc(width / 2, height / 2 + 60, 100, 60, 0, PI);

// 몬드리안 스타일 요소
// 가로 선
stroke(255, 255, 255);
strokeWeight(10);
line(0, height / 2, width, height / 2);
line(0, height / 2 + 100, width, height / 2 + 100);
line(0, height / 2 + 200, width, height / 2 + 200);
line(0, height / 2 + 300, width, height / 2 + 300);

// 세로 선
line(width / 2, 0, width / 2, height);
line(width / 2 + 100, 0, width / 2 + 100, height);
line(width / 2 + 200, 0, width / 2 + 200, height);
line(width / 2 + 300, 0, width / 2 + 300, height);
}

void drawPerson(float x, float y, int index) {
// 각 사람의 위치에 따라 표정을 다르게 그립니다.
if (index == 0) {
// 첫 번째 사람
drawExpression(x, y, expressions[0]);
} else if (index == 1) {
// 두 번째 사람
drawExpression(x, y, expressions[1]);
} else if (index == 2) {
// 세 번째 사람
drawExpression(x, y, expressions[2]);
}
}

void drawExpression(float x, float y, int expression) {
// 표정에 따라 그림을 그립니다.
if (expression == 0) {
// 행복한 표정
fill(247, 220, 111);
ellipse(x, y, 200, 200);

// 눈
fill(0);
ellipse(x - 40, y - 20, 30, 30);
ellipse(x + 40, y - 20, 30, 30);

// 코
fill(255, 125, 75);
triangle(x, y + 10, x - 20, y + 40, x + 20, y + 40);

// 입 (웃는 표정)
noFill();
stroke(0);
strokeWeight(4);
arc(x, y + 60, 100, 60, 0, PI);
} else if (expression == 1) {
// 슬픈 표정
fill(247, 220, 111);
ellipse(x, y, 200, 200);

// 눈
fill(0);
ellipse(x - 40, y - 20, 30, 10);
ellipse(x + 40, y - 20, 30, 10);

// 코
fill(255, 125, 75);
triangle(x, y + 10, x - 20, y + 40, x + 20, y + 40);

// 입 (슬픈 표정)
noFill();
stroke(0);
strokeWeight(4);
arc(x, y + 80, 100, 40, PI, TWO_PI);
} else if (expression == 2) {
// 놀란 표정
fill(247, 220, 111);
ellipse(x, y, 200, 200);

// 눈
fill(0);
ellipse(x - 40, y - 20, 10, 30);
ellipse(x + 40, y - 20, 10, 30);

// 코
fill(255, 125, 75);
triangle(x, y + 10, x - 20, y + 40, x + 20, y + 40);

// 입 (놀란 표정)
noFill();
stroke(0);
strokeWeight(4);
arc(x, y + 60, 100, 80, PI + QUARTER_PI, TWO_PI - QUARTER_PI);
}

}

void updateExpressions() {
// 각 사람의 표정을 업데이트합니다.
for (int i = 0; i < expressions.length; i++) {
expressions[i] = floor(random(3)); // 0, 1, 2 중 하나의 표정을 랜덤하게 선택
}
}

void randomExpressions() {
// 초기 표정을 랜덤하게 설정합니다.
for (int i = 0; i < expressions.length; i++) {
expressions[i] = floor(random(3)); // 0, 1, 2 중 하나의 표정을 랜덤하게 선택
}
}

void mousePressed() {
if (isClicked) {
personCount = 1;
isClicked = false;
background(0);
} else {
if (personCount < 3) {
personCount++;
} else {
personCount = 1;
}
isClicked = true;
}
}

# data[].attributes.body
float angle = 0; // 회전 각도 변수

float radius = 150; // 꽃잎 반지름 변수

int petalCount = 30; // 꽃잎 개수 변수

void setup() {

size(400, 400);

background(0);

smooth();

}

void draw() {

background(0);

// 중앙으로 이동

translate(width / 2, height / 2);

// 꽃잎 그리기

float angleStep = TWO_PI / petalCount; // 꽃잎 사이의 각도 간격

for (int i = 0; i < petalCount; i++) {

// 꽃잎의 회전 각도

float petalAngle = angle + i * angleStep;

// 꽃잎의 위치 계산

float x = cos(petalAngle) * radius;

float y = sin(petalAngle) * radius;

// 꽃잎 그리기

fill(random(205), random(255), random(255));

ellipse(x, y, 40, 80);

}

// 회전 속도 업데이트

angle += 0.01;
saveFrame("my image_####.png");

}

# data[].attributes.body
int numCircles = 20; // 총 원의 개수
Circle[] circles = new Circle[numCircles];

void setup() {
size(800, 600);
for (int i = 0; i < numCircles; i++) {
float x = random(width);
float y = random(height);
float radius = random(20, 40);
float speedX = random(-3, 3);
float speedY = random(-3, 3);
color fillColor = color(random(255), random(255), random(255), 200);
Circle circle = new Circle(x, y, radius, speedX, speedY, fillColor);
circles[i] = circle;
}
}

void draw() {
background(0);

for (int i = 0; i < numCircles; i++) {
circles[i].move();
circles[i].checkEdges();
circles[i].checkCollision(circles);
circles[i].vibrate();
circles[i].changeColor();
circles[i].display();
}
}

class Circle {
float x, y; // 좌표
float radius; // 반지름
float speedX, speedY; // 속도
color fillColor; // 채움 색상

float vibration = 1.0; // 진동 정도
int colorChangeInterval = 30; // 색상 변화 간격 (0.03초)
int lastColorChange = millis(); // 마지막 색상 변화 시간

Circle(float x, float y, float radius, float speedX, float speedY, color fillColor) {
this.x = x;
this.y = y;
this.radius = radius;
this.speedX = speedX;
this.speedY = speedY;
this.fillColor = fillColor;
}

void move() {
x += speedX;
y += speedY;
}

void checkEdges() {
if (x - radius < 0 || x + radius > width) {
speedX *= -1;
}
if (y - radius < 0 || y + radius > height) {
speedY *= -1;
}
}

void checkCollision(Circle[] circles) {
for (int i = 0; i < numCircles; i++) {
if (circles[i] != this) {
float distance = dist(x, y, circles[i].x, circles[i].y);
float minDist = radius + circles[i].radius;
if (distance < minDist) {
float angle = atan2(y - circles[i].y, x - circles[i].x);
speedX = cos(angle) * abs(speedX);
speedY = sin(angle) * abs(speedY);
}
}
}
}

void vibrate() {
x += random(-vibration, vibration);
y += random(-vibration, vibration);
}

void changeColor() {
if (millis() - lastColorChange > colorChangeInterval) {
fillColor = color(random(255), random(255), random(255), 200);
lastColorChange = millis();
}
}

void display() {
fill(fillColor);
ellipse(x, y, radius * 2, radius * 2);
saveFrame("my image_#####.png");
}
}

# data[].attributes.body
ArrayList<FloatingCircle> circles = new ArrayList<FloatingCircle>();
color backgroundColor;

class FloatingCircle {
float x, y;
float radius;
float speedX, speedY;
color circleColor;

FloatingCircle(float xPos, float yPos, float rad, float xSpeed, float ySpeed) {
x = xPos;
y = yPos;
radius = rad;
speedX = xSpeed;
speedY = ySpeed;
circleColor = color(random(255), random(255), random(255));
}

void update() {
x += speedX;
y += speedY;

// 화면 벗어난 경우 반대 방향으로 이동
if (x > width - radius || x < radius) {
speedX *= -1;
}
if (y > height - radius || y < radius) {
speedY *= -1;
}

// 색상 변경
if (frameCount % 30 == 0) { // 0.5초마다 (30 프레임마다)
circleColor = color(random(255), random(255), random(255));
}
}

void display() {
fill(circleColor);
noStroke();
ellipse(x, y, radius * 2, radius * 2);
}
}

void setup() {
size(500, 500);
backgroundColor = color(0); // 초기 배경색을 검은색으로 설정

for (int i = 0; i < 100; i++) {
float x = random(width);
float y = random(height);
float radius = random(20, 50);
float speedX = random(-3, 3);
float speedY = random(-3, 3);

circles.add(new FloatingCircle(x, y, radius, speedX, speedY));
}
}

void draw() {
background(backgroundColor);

for (FloatingCircle circle : circles) {
circle.update();
circle.display();
}

// 배경색을 점진적으로 변경
backgroundColor = color(random(255), random(255), random(255));
saveFrame("my image_####.png");
}