2021年8月 – ページ 5 – プログラミング de 落描き

2021年8月19日2021年8月19日

Convert frame number to z coordination. Draw by openFrameworks

[ Video ]

[ About ]
我が家の世界一可愛い猫。

The world’s cutest cat in our house.

[ Source ]

#pragma once
#include "ofMain.h"
#include "opencv2/opencv.hpp"

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	ofEasyCam cam;

	cv::VideoCapture cap;
	cv::Size cap_size;
	deque<cv::Mat> frame_list;
	int frame_list_count;

	float rect_size;
	vector<cv::Mat> rect_frames;
	vector<unique_ptr<ofImage>> rect_images;
	vector<cv::Rect> cv_rects;
};

#pragma once

#include "ofMain.h"

#include "opencv2/opencv.hpp"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

ofEasyCam cam;

cv::VideoCapture cap;

cv::Size cap_size;

deque<cv::Mat> frame_list;

int frame_list_count;

float rect_size;

vector<cv::Mat> rect_frames;

vector<unique_ptr<ofImage>> rect_images;

vector<cv::Rect> cv_rects;

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofSetColor(255);
	ofEnableDepthTest();
	ofDisableArbTex();

	this->cap.open("D:\\MP4\\MOV_0031.mp4"); // Kinako URL https://www.youtube.com/channel/UCUwl7IYYfueE3ruHedfG7MA
	this->cap_size = cv::Size(360, 360);

	this->rect_size = 40;
	for (int x = 0; x < this->cap_size.width; x += this->rect_size) {

		for (int y = 0; y < this->cap_size.height; y += this->rect_size) {

			auto image = make_unique<ofImage>();
			image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);
			cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);
			cv::Rect rect = cv::Rect(x, y, this->rect_size, this->rect_size);

			this->rect_images.push_back(move(image));
			this->cv_rects.push_back(rect);
			this->rect_frames.push_back(frame);
		}
	}

	while (true) {

		cv::Mat frame, resize, cut;
		this->cap >> frame;
		if (frame.empty()) {

			break;
		}

		cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
		cv::resize(frame, resize, cv::Size(640, 360));
		cut = cv::Mat(resize, cv::Rect(140, 0, 360, 360));

		this->frame_list.push_front(cut);
	}
}

//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);
}

//--------------------------------------------------------------
void ofApp::draw() {

	this->cam.begin();
	ofRotateY(sin(ofGetFrameNum() * 0.01) * 30);
	ofRotateX(sin(ofGetFrameNum() * 0.02) * 15);

	ofTranslate(this->cap_size.width * -0.5 + this->rect_size * 0.5, this->cap_size.height * -0.5 - this->rect_size * 0.5, 0);

	float noise_seed = ofRandom(1000);
	for (int i = 0; i < this->rect_frames.size(); i++) {

		int frame_index = ofMap(ofNoise(noise_seed, this->cv_rects[i].x * 0.005, this->cv_rects[i].y * 0.005, ofGetFrameNum() * 0.01), 0, 1, 0, this->frame_list.size());

		cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);
		tmp_box_image.copyTo(this->rect_frames[i]);

		auto z = ofMap(frame_index, 0, this->frame_list.size(), -125, 125);

		this->rect_images[i]->update();
		this->rect_images[i]->getTexture().bind();
		ofSetColor(255);
		ofFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, z), this->rect_size, this->rect_size, 5);
		this->rect_images[i]->unbind();

		ofSetColor(39);
		ofNoFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, z), this->rect_size, this->rect_size, 5);
		ofSetColor(139);
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 200);
	}

	this->cam.end();
}

//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

#include "ofApp.h"

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetColor(255);

ofEnableDepthTest();

ofDisableArbTex();

this->cap.open("D:\\MP4\\MOV_0031.mp4"); // Kinako URL https://www.youtube.com/channel/UCUwl7IYYfueE3ruHedfG7MA

this->cap_size = cv::Size(360, 360);

this->rect_size = 40;

for (int x = 0; x < this->cap_size.width; x += this->rect_size) {

for (int y = 0; y < this->cap_size.height; y += this->rect_size) {

auto image = make_unique<ofImage>();

image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);

cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);

cv::Rect rect = cv::Rect(x, y, this->rect_size, this->rect_size);

this->rect_images.push_back(move(image));

this->cv_rects.push_back(rect);

this->rect_frames.push_back(frame);

}

while (true) {

cv::Mat frame, resize, cut;

this->cap >> frame;

if (frame.empty()) {

break;

}

cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);

cv::resize(frame, resize, cv::Size(640, 360));

cut = cv::Mat(resize, cv::Rect(140, 0, 360, 360));

this->frame_list.push_front(cut);

}

//--------------------------------------------------------------

void ofApp::update() {

ofSeedRandom(39);

}

//--------------------------------------------------------------

void ofApp::draw() {

this->cam.begin();

ofRotateY(sin(ofGetFrameNum() * 0.01) * 30);

ofRotateX(sin(ofGetFrameNum() * 0.02) * 15);

ofTranslate(this->cap_size.width * -0.5 + this->rect_size * 0.5, this->cap_size.height * -0.5 - this->rect_size * 0.5, 0);

float noise_seed = ofRandom(1000);

for (int i = 0; i < this->rect_frames.size(); i++) {

int frame_index = ofMap(ofNoise(noise_seed, this->cv_rects[i].x * 0.005, this->cv_rects[i].y * 0.005, ofGetFrameNum() * 0.01), 0, 1, 0, this->frame_list.size());

cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);

tmp_box_image.copyTo(this->rect_frames[i]);

auto z = ofMap(frame_index, 0, this->frame_list.size(), -125, 125);

this->rect_images[i]->update();

this->rect_images[i]->getTexture().bind();

ofSetColor(255);

ofFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, z), this->rect_size, this->rect_size, 5);

this->rect_images[i]->unbind();

ofSetColor(39);

ofNoFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, z), this->rect_size, this->rect_size, 5);

ofSetColor(139);

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 200);

}

this->cam.end();

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20210819

[ Kinako ]

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2021年8月18日2021年8月18日

Multi frame movie. Draw by openFrameworks

[ Video ]

[ About ]
OpenCVのcv::MatとopenFrameworksのofImageを関連づける。

Associate OpenCV’s cv::Mat with openFrameworks’ ofImage.

auto image = make_unique<ofImage>();
image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);
cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);

auto image = make_unique<ofImage>();

image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);

cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);

[ Source ]

#pragma once
#include "ofMain.h"
#include "opencv2/opencv.hpp"

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	ofEasyCam cam;

	cv::VideoCapture cap;
	cv::Size cap_size;
	deque<cv::Mat> frame_list;
	int frame_list_count;

	float rect_size;
	vector<cv::Mat> rect_frames;
	vector<unique_ptr<ofImage>> rect_images;
	vector<cv::Rect> cv_rects;
};

#pragma once

#include "ofMain.h"

#include "opencv2/opencv.hpp"

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

ofEasyCam cam;

cv::VideoCapture cap;

cv::Size cap_size;

deque<cv::Mat> frame_list;

int frame_list_count;

float rect_size;

vector<cv::Mat> rect_frames;

vector<unique_ptr<ofImage>> rect_images;

vector<cv::Rect> cv_rects;

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofSetColor(255);
	ofEnableDepthTest();
	ofDisableArbTex();

	this->frame_list_count = 60;

	this->cap.open("D:\\MP4\\production ID_4711774.mp4"); // Video URL https://www.pexels.com/video/video-of-streets-in-japan-during-daytime-4711774/
	this->cap_size = cv::Size(640, 360);

	this->rect_size = 40;
	for (int x = 0; x < this->cap_size.width; x += this->rect_size) {

		for (int y = 0; y < this->cap_size.height; y += this->rect_size) {

			auto image = make_unique<ofImage>();
			image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);
			cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);
			cv::Rect rect = cv::Rect(x, y, this->rect_size, this->rect_size);

			this->rect_images.push_back(move(image));
			this->cv_rects.push_back(rect);
			this->rect_frames.push_back(frame);
		}
	}
}

//--------------------------------------------------------------
void ofApp::update() {

	ofSeedRandom(39);

	cv::Mat frame, resize;

	this->cap >> frame;
	if (frame.empty()) { 
		
		this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);
		return; 
	}

	cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
	cv::resize(frame, resize, this->cap_size);

	this->frame_list.push_front(resize);
	while (this->frame_list.size() > this->frame_list_count) {

		this->frame_list.pop_back();
	}
}

//--------------------------------------------------------------
void ofApp::draw() {

	this->cam.begin();
	ofTranslate(this->cap_size.width * -0.5 + this->rect_size * 0.5, this->cap_size.height * -0.5 - this->rect_size * 0.5, 0);

	for (int i = 0; i < this->rect_frames.size(); i++) {

		float noise_seed = ofRandom(1000);
		int frame_index = ofMap(ofNoise(noise_seed, this->cv_rects[i].x * 0.005, this->cv_rects[i].y * 0.005, ofGetFrameNum() * 0.01), 0, 1, 0, this->frame_list.size());

		cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);
		tmp_box_image.copyTo(this->rect_frames[i]);

		this->rect_images[i]->update();
		this->rect_images[i]->getTexture().bind();
		ofSetColor(255);
		ofFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);
		this->rect_images[i]->unbind();

		ofSetColor(39);
		ofNoFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);
	}

	/*
	// 元動画と比べる時にはコメントを外す

	ofTranslate(0, this->cap_size.height * 1.2);

	for (int i = 0; i < this->rect_frames.size(); i++) {

		int frame_index = 0;

		cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);
		tmp_box_image.copyTo(this->rect_frames[i]);

		this->rect_images[i]->update();
		this->rect_images[i]->getTexture().bind();
		ofSetColor(255);
		ofFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);
		this->rect_images[i]->unbind();

		ofSetColor(39);
		ofNoFill();
		ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);
	}
	*/

	this->cam.end();
}

//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

#include "ofApp.h"

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetColor(255);

ofEnableDepthTest();

ofDisableArbTex();

this->frame_list_count = 60;

this->cap.open("D:\\MP4\\production ID_4711774.mp4"); // Video URL https://www.pexels.com/video/video-of-streets-in-japan-during-daytime-4711774/

this->cap_size = cv::Size(640, 360);

this->rect_size = 40;

for (int x = 0; x < this->cap_size.width; x += this->rect_size) {

for (int y = 0; y < this->cap_size.height; y += this->rect_size) {

auto image = make_unique<ofImage>();

image->allocate(this->rect_size, this->rect_size, OF_IMAGE_COLOR);

cv::Mat frame = cv::Mat(cv::Size(image->getWidth(), image->getHeight()), CV_MAKETYPE(CV_8UC3, image->getPixels().getNumChannels()), image->getPixels().getData(), 0);

cv::Rect rect = cv::Rect(x, y, this->rect_size, this->rect_size);

this->rect_images.push_back(move(image));

this->cv_rects.push_back(rect);

this->rect_frames.push_back(frame);

}

//--------------------------------------------------------------

void ofApp::update() {

ofSeedRandom(39);

cv::Mat frame, resize;

this->cap >> frame;

if (frame.empty()) {

this->cap.set(cv::CAP_PROP_POS_FRAMES, 0);

return;

}

cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);

cv::resize(frame, resize, this->cap_size);

this->frame_list.push_front(resize);

while (this->frame_list.size() > this->frame_list_count) {

this->frame_list.pop_back();

}

//--------------------------------------------------------------

void ofApp::draw() {

this->cam.begin();

ofTranslate(this->cap_size.width * -0.5 + this->rect_size * 0.5, this->cap_size.height * -0.5 - this->rect_size * 0.5, 0);

for (int i = 0; i < this->rect_frames.size(); i++) {

float noise_seed = ofRandom(1000);

int frame_index = ofMap(ofNoise(noise_seed, this->cv_rects[i].x * 0.005, this->cv_rects[i].y * 0.005, ofGetFrameNum() * 0.01), 0, 1, 0, this->frame_list.size());

cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);

tmp_box_image.copyTo(this->rect_frames[i]);

this->rect_images[i]->update();

this->rect_images[i]->getTexture().bind();

ofSetColor(255);

ofFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);

this->rect_images[i]->unbind();

ofSetColor(39);

ofNoFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);

}

// 元動画と比べる時にはコメントを外す

ofTranslate(0, this->cap_size.height * 1.2);

for (int i = 0; i < this->rect_frames.size(); i++) {

int frame_index = 0;

cv::Mat tmp_box_image(this->frame_list[frame_index], this->cv_rects[i]);

tmp_box_image.copyTo(this->rect_frames[i]);

this->rect_images[i]->update();

this->rect_images[i]->getTexture().bind();

ofSetColor(255);

ofFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);

this->rect_images[i]->unbind();

ofSetColor(39);

ofNoFill();

ofDrawBox(glm::vec3(this->cv_rects[i].x, this->cap_size.height - this->cv_rects[i].y, 0), this->rect_size, this->rect_size, 5);

}

this->cam.end();

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20210818
https://www.pexels.com/video/video-of-streets-in-japan-during-daytime-4711774/

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2021年8月17日2021年8月17日

Scrap and build. Draw by openFrameworks

[ Video ]

[ About ]
ffmpegを使って、キャプチャ動画とそれをリバースさせた動画を合成する。

Using ffmpeg, synthesize the captured video and the video that was reversed from it.

[ Source ]

#pragma once
#include "ofMain.h"

class Actor {
public:
	Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);
	Actor(int select_index, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);
	void update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);
	glm::vec3 getLocation();
	deque<glm::vec3> getLog();

private:

	int select_index;
	int next_index;

	glm::vec3 location;
	deque<glm::vec3> log;
};

class ofApp : public ofBaseApp {

public:
	void setup();
	void update();
	void draw();

	void keyPressed(int key) {
		
		if (key == 'r' && key == 'R') {

			this->rec_flag = true;
		}
	};
	void keyReleased(int key) {};
	void mouseMoved(int x, int y) {};
	void mouseDragged(int x, int y, int button) {};
	void mousePressed(int x, int y, int button) {};
	void mouseReleased(int x, int y, int button) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	bool rec_flag = false;

	ofTrueTypeFont font;
	vector<string> word_list;
	int word_index;

	vector<glm::vec3> location_list;
	vector<vector<int>> next_index_list;
	vector<int> destination_list;

	vector<unique_ptr<Actor>> actor_list;

	ofEasyCam cam;
};

#pragma once

#include "ofMain.h"

class Actor {

public:

Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);

Actor(int select_index, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);

void update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list);

glm::vec3 getLocation();

deque<glm::vec3> getLog();

private:

int select_index;

int next_index;

glm::vec3 location;

deque<glm::vec3> log;

};

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void keyPressed(int key) {

if (key == 'r' && key == 'R') {

this->rec_flag = true;

}

};

void keyReleased(int key) {};

void mouseMoved(int x, int y) {};

void mouseDragged(int x, int y, int button) {};

void mousePressed(int x, int y, int button) {};

void mouseReleased(int x, int y, int button) {};

void windowResized(int w, int h) {};

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

bool rec_flag = false;

ofTrueTypeFont font;

vector<string> word_list;

int word_index;

vector<glm::vec3> location_list;

vector<vector<int>> next_index_list;

vector<int> destination_list;

vector<unique_ptr<Actor>> actor_list;

ofEasyCam cam;

};

#include "ofApp.h"	

//--------------------------------------------------------------
Actor::Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

	this->select_index = ofRandom(location_list.size());
	while (true) {

		auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);
		if (itr == destination_list.end()) {

			destination_list.push_back(this->select_index);
			break;
		}

		this->select_index = (this->select_index + 1) % location_list.size();
	}

	this->next_index = this->select_index;
}

//--------------------------------------------------------------
Actor::Actor(int select_index, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

	this->select_index = select_index;
	while (true) {

		auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);
		if (itr == destination_list.end()) {

			destination_list.push_back(this->select_index);
			break;
		}

		this->select_index = (this->select_index + 1) % location_list.size();
	}

	this->next_index = this->select_index;

	this->location = location_list[this->select_index];
}

//--------------------------------------------------------------
void Actor::update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

	if (ofGetFrameNum() % frame_span == 0) {

		auto tmp_index = this->select_index;
		this->select_index = this->next_index;
		int retry = next_index_list[this->select_index].size();
		this->next_index = next_index_list[this->select_index][(int)ofRandom(next_index_list[this->select_index].size())];
		while (--retry > 0) {

			auto destination_itr = find(destination_list.begin(), destination_list.end(), this->next_index);
			if (destination_itr == destination_list.end()) {

				if (tmp_index != this->next_index) {

					destination_list.push_back(this->next_index);
					break;
				}
			}

			this->next_index = next_index_list[this->select_index][(this->next_index + 1) % next_index_list[this->select_index].size()];
		}
		if (retry <= 0) {

			destination_list.push_back(this->select_index);
			this->next_index = this->select_index;
		}
	}

	auto param = ofGetFrameNum() % frame_span;
	auto distance = location_list[this->next_index] - location_list[this->select_index];
	this->location = location_list[this->select_index] + distance / frame_span * param;

	this->log.push_front(this->location);
	while (this->log.size() > 50) { this->log.pop_back(); }
}

//--------------------------------------------------------------
glm::vec3 Actor::getLocation() {

	return this->location;
}

//--------------------------------------------------------------
deque<glm::vec3> Actor::getLog() {

	return this->log;
}

//--------------------------------------------------------------
void ofApp::setup() {

	ofSetFrameRate(60);
	ofSetWindowTitle("openFrameworks");

	ofBackground(239);
	ofSetLineWidth(2);
	ofEnableDepthTest();

	this->font.loadFont("fonts/Kazesawa-Bold.ttf", 350, true, true, true);

	this->word_list = vector<string>{ "S", "&", "B" };
	this->word_index = 0;
}

//--------------------------------------------------------------
void ofApp::update() {

	if (ofGetFrameNum() % 120 == 0) {

		this->location_list.clear();
		this->next_index_list.clear();
		this->destination_list.clear();
		this->actor_list.clear();

		auto span = 8;

		for (int x = span * 10; x < ofGetWidth() - span * 10; x += span) {

			for (int y = span * 10; y < ofGetHeight() - span * 10; y += span) {

				for (int z = -300; z <= 300; z += 300) {

					this->location_list.push_back(glm::vec3(x, y, z));
				}
			}
		}

		for (auto& location : this->location_list) {

			vector<int> next_index = vector<int>();
			int index = -1;
			for (auto& other : this->location_list) {

				index++;
				if (location == other) { continue; }

				float distance = glm::distance(location, other);
				if (distance <= span) {

					if (location.x > ofGetWidth() * 0.5 && location.x <= other.x) {

						if (location.y > ofGetHeight() * 0.5 && location.y <= other.y) {

							next_index.push_back(index);
						}

						if (location.y <= ofGetHeight() * 0.5 && location.y >= other.y) {

							next_index.push_back(index);
						}
					}

					if (location.x <= ofGetWidth() * 0.5 && location.x >= other.x) {

						if (location.y > ofGetHeight() * 0.5 && location.y <= other.y) {

							next_index.push_back(index);
						}

						if (location.y <= ofGetHeight() * 0.5 && location.y >= other.y) {

							next_index.push_back(index);
						}
					}
				}
			}

			this->next_index_list.push_back(next_index);
		}

		for (int z = -300; z <= 300; z += 300) {

			ofFbo fbo;
			fbo.allocate(ofGetWidth(), ofGetHeight());
			fbo.begin();
			ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);
			ofClear(0);
			ofSetColor(0);

			string word = this->word_list[this->word_index];
			this->word_index = (this->word_index + 1) % this->word_list.size();
			this->font.drawString(word, this->font.stringWidth(word) * -0.5, this->font.stringHeight(word) - 150);

			fbo.end();

			ofPixels pixels;
			fbo.readToPixels(pixels);
			for (int x = 0; x < fbo.getWidth(); x += span) {

				for (int y = 0; y < fbo.getHeight(); y += span) {

					ofColor color = pixels.getColor(x, y);
					if (color != ofColor(0, 0)) {

						for (int i = 0; i < this->location_list.size(); i++) {

							if (this->location_list[i] == glm::vec3(x, y, z)) {

								this->actor_list.push_back(make_unique<Actor>(i, this->location_list, this->next_index_list, this->destination_list));
								break;
							}
						}
					}
				}
			}
		}
	}

	if (ofGetFrameNum() % 120 < 15) {

		return;
	}

	int frame_span = 1;
	int prev_index_size = 0;

	if (ofGetFrameNum() % frame_span == 0) {

		prev_index_size = this->destination_list.size();
	}

	for (auto& actor : this->actor_list) {

		actor->update(frame_span, this->location_list, this->next_index_list, this->destination_list);
	}

	if (prev_index_size != 0) {

		this->destination_list.erase(this->destination_list.begin(), this->destination_list.begin() + prev_index_size);
	}
}

//--------------------------------------------------------------
void ofApp::draw() {

	this->cam.begin();
	ofRotateX(180);
	ofTranslate(ofGetWidth() * -0.5, ofGetHeight() * -0.5, 300);	

	for (auto& actor : this->actor_list) {

		ofSetColor(39);
		ofFill();
		ofDrawBox(actor->getLocation(), 8);

		ofSetColor(239);
		ofNoFill();
		ofDrawBox(actor->getLocation(), 8);
	}

	this->cam.end();
}


//--------------------------------------------------------------
int main() {

	ofSetupOpenGL(720, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

#include "ofApp.h"

//--------------------------------------------------------------

Actor::Actor(vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

this->select_index = ofRandom(location_list.size());

while (true) {

auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);

if (itr == destination_list.end()) {

destination_list.push_back(this->select_index);

break;

}

this->select_index = (this->select_index + 1) % location_list.size();

}

this->next_index = this->select_index;

}

//--------------------------------------------------------------

Actor::Actor(int select_index, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

this->select_index = select_index;

while (true) {

auto itr = find(destination_list.begin(), destination_list.end(), this->select_index);

if (itr == destination_list.end()) {

destination_list.push_back(this->select_index);

break;

}

this->select_index = (this->select_index + 1) % location_list.size();

}

this->next_index = this->select_index;

this->location = location_list[this->select_index];

}

//--------------------------------------------------------------

void Actor::update(const int& frame_span, vector<glm::vec3>& location_list, vector<vector<int>>& next_index_list, vector<int>& destination_list) {

if (ofGetFrameNum() % frame_span == 0) {

auto tmp_index = this->select_index;

this->select_index = this->next_index;

int retry = next_index_list[this->select_index].size();

this->next_index = next_index_list[this->select_index][(int)ofRandom(next_index_list[this->select_index].size())];

while (--retry > 0) {

auto destination_itr = find(destination_list.begin(), destination_list.end(), this->next_index);

if (destination_itr == destination_list.end()) {

if (tmp_index != this->next_index) {

destination_list.push_back(this->next_index);

break;

}

this->next_index = next_index_list[this->select_index][(this->next_index + 1) % next_index_list[this->select_index].size()];

}

if (retry <= 0) {

destination_list.push_back(this->select_index);

this->next_index = this->select_index;

}

auto param = ofGetFrameNum() % frame_span;

auto distance = location_list[this->next_index] - location_list[this->select_index];

this->location = location_list[this->select_index] + distance / frame_span * param;

this->log.push_front(this->location);

while (this->log.size() > 50) { this->log.pop_back(); }

}

//--------------------------------------------------------------

glm::vec3 Actor::getLocation() {

return this->location;

}

//--------------------------------------------------------------

deque<glm::vec3> Actor::getLog() {

return this->log;

}

//--------------------------------------------------------------

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openFrameworks");

ofBackground(239);

ofSetLineWidth(2);

ofEnableDepthTest();

this->font.loadFont("fonts/Kazesawa-Bold.ttf", 350, true, true, true);

this->word_list = vector<string>{ "S", "&", "B" };

this->word_index = 0;

}

//--------------------------------------------------------------

void ofApp::update() {

if (ofGetFrameNum() % 120 == 0) {

this->location_list.clear();

this->next_index_list.clear();

this->destination_list.clear();

this->actor_list.clear();

auto span = 8;

for (int x = span * 10; x < ofGetWidth() - span * 10; x += span) {

for (int y = span * 10; y < ofGetHeight() - span * 10; y += span) {

for (int z = -300; z <= 300; z += 300) {

this->location_list.push_back(glm::vec3(x, y, z));

}

for (auto& location : this->location_list) {

vector<int> next_index = vector<int>();

int index = -1;

for (auto& other : this->location_list) {

index++;

if (location == other) { continue; }

float distance = glm::distance(location, other);

if (distance <= span) {

if (location.x > ofGetWidth() * 0.5 && location.x <= other.x) {

if (location.y > ofGetHeight() * 0.5 && location.y <= other.y) {

next_index.push_back(index);

}

if (location.y <= ofGetHeight() * 0.5 && location.y >= other.y) {

next_index.push_back(index);

}

if (location.x <= ofGetWidth() * 0.5 && location.x >= other.x) {

if (location.y > ofGetHeight() * 0.5 && location.y <= other.y) {

next_index.push_back(index);

}

if (location.y <= ofGetHeight() * 0.5 && location.y >= other.y) {

next_index.push_back(index);

}

this->next_index_list.push_back(next_index);

}

for (int z = -300; z <= 300; z += 300) {

ofFbo fbo;

fbo.allocate(ofGetWidth(), ofGetHeight());

fbo.begin();

ofTranslate(ofGetWidth() * 0.5, ofGetHeight() * 0.5);

ofClear(0);

ofSetColor(0);

string word = this->word_list[this->word_index];

this->word_index = (this->word_index + 1) % this->word_list.size();

this->font.drawString(word, this->font.stringWidth(word) * -0.5, this->font.stringHeight(word) - 150);

fbo.end();

ofPixels pixels;

fbo.readToPixels(pixels);

for (int x = 0; x < fbo.getWidth(); x += span) {

for (int y = 0; y < fbo.getHeight(); y += span) {

ofColor color = pixels.getColor(x, y);

if (color != ofColor(0, 0)) {

for (int i = 0; i < this->location_list.size(); i++) {

if (this->location_list[i] == glm::vec3(x, y, z)) {

this->actor_list.push_back(make_unique<Actor>(i, this->location_list, this->next_index_list, this->destination_list));

break;

}

if (ofGetFrameNum() % 120 < 15) {

return;

}

int frame_span = 1;

int prev_index_size = 0;

if (ofGetFrameNum() % frame_span == 0) {

prev_index_size = this->destination_list.size();

}

for (auto& actor : this->actor_list) {

actor->update(frame_span, this->location_list, this->next_index_list, this->destination_list);

}

if (prev_index_size != 0) {

this->destination_list.erase(this->destination_list.begin(), this->destination_list.begin() + prev_index_size);

}

//--------------------------------------------------------------

void ofApp::draw() {

this->cam.begin();

ofRotateX(180);

ofTranslate(ofGetWidth() * -0.5, ofGetHeight() * -0.5, 300);

for (auto& actor : this->actor_list) {

ofSetColor(39);

ofFill();

ofDrawBox(actor->getLocation(), 8);

ofSetColor(239);

ofNoFill();

ofDrawBox(actor->getLocation(), 8);

}

this->cam.end();

}

//--------------------------------------------------------------

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

[ Link ]
https://github.com/junkiyoshi/Insta20210817

[ Kinako ]

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2021年8月
月	火	水	木	金	土	日
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31