プログラミング de 落描き – ページ 778 – クリエイティブ・コーディングによる生成物とソース

2018年7月4日2018年7月4日

360度動画その2 openFrameworks

[ Video ]

[ About ]
動画を円状に配置して、それぞれの再生フレームを位置情報を引数にしたNoise関数で変化させてみました

[ 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;
	int number_of_frames;

	vector<cv::Mat> cap_frames;
	vector<cv::Mat> frames;
	vector<ofImage*> images;
};

#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;

int number_of_frames;

vector<cv::Mat> cap_frames;

vector<cv::Mat> frames;

vector<ofImage*> images;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("Insta");

	ofBackground(239);
	ofEnableDepthTest();
	ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

	this->cap.open("D:\\video\\image19.mp4");
	this->cap_size = cv::Size(320, 180);

	this->number_of_frames = this->cap.get(CV_CAP_PROP_FRAME_COUNT);
	for (int i = 0; i < number_of_frames; i++) {

		cv::Mat src, mini_src;
		this->cap >> src;
		cv::resize(src, mini_src, this->cap_size);
		cv::cvtColor(mini_src, mini_src, CV_BGR2RGB);

		ofImage* image = new ofImage();
		image->allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
		this->images.push_back(image);

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

		mini_src.copyTo(frame);
		image->update();
	}
}

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

}

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

	this->cam.begin();
	ofRotateX(270);

	int radius = 930;
	int deg_span = 20;

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

		int noise_deg = ofMap(ofNoise(z * 0.005, ofGetFrameNum() * 0.003), 0, 1, -360, 360);
		for (int deg = 0; deg < 360; deg += deg_span) {

			ofPoint point(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z);

			ofPushMatrix();
			ofTranslate(point);
			ofRotateX(90);
			ofRotateY(deg + 90);

			int images_index = ofMap(ofNoise(point.x * 0.0005, point.y * 0.0005, point.z * 0.0005, ofGetFrameNum() * 0.005), 0, 1, 0, this->number_of_frames);
			this->images[images_index]->draw(0, 0);

			ofPopMatrix();
		}
	}
	
	this->cam.end();
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("Insta");

ofBackground(239);

ofEnableDepthTest();

ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

this->cap.open("D:\\video\\image19.mp4");

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

this->number_of_frames = this->cap.get(CV_CAP_PROP_FRAME_COUNT);

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

cv::Mat src, mini_src;

this->cap >> src;

cv::resize(src, mini_src, this->cap_size);

cv::cvtColor(mini_src, mini_src, CV_BGR2RGB);

ofImage* image = new ofImage();

image->allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);

this->images.push_back(image);

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

this->frames.push_back(frame);

mini_src.copyTo(frame);

image->update();

}

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

void ofApp::update() {

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(270);

int radius = 930;

int deg_span = 20;

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

int noise_deg = ofMap(ofNoise(z * 0.005, ofGetFrameNum() * 0.003), 0, 1, -360, 360);

for (int deg = 0; deg < 360; deg += deg_span) {

ofPoint point(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD), z);

ofPushMatrix();

ofTranslate(point);

ofRotateX(90);

ofRotateY(deg + 90);

int images_index = ofMap(ofNoise(point.x * 0.0005, point.y * 0.0005, point.z * 0.0005, ofGetFrameNum() * 0.005), 0, 1, 0, this->number_of_frames);

this->images[images_index]->draw(0, 0);

ofPopMatrix();

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(1280, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年7月3日2018年7月3日

もじおらま海 openFrameworks

[ Video ]

[ About ]
もじおらま。夏の海・エディション

[ Source ]

#pragma once
#include "ofMain.h"

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;
	ofTrueTypeFont font;
	ofTrueTypeFont font_small;

	void draw_ocean();
	void draw_beach();
	void draw_human(ofPoint point);
};

#pragma once

#include "ofMain.h"

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;

ofTrueTypeFont font;

ofTrueTypeFont font_small;

void draw_ocean();

void draw_beach();

void draw_human(ofPoint point);

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofBackground(239);
	ofSetWindowTitle("Insta");

	ofEnableDepthTest();
	this->font.loadFont("fonts/Kazesawa-Extrabold.ttf", 50, true, false, true);
	this->font_small.loadFont("fonts/Kazesawa-Extrabold.ttf", 25, true, false, true);
}

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

	ofSeedRandom(39);
}

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

	this->cam.begin();
	ofRotateX(180);

	this->draw_ocean();
	this->draw_beach();
	
	for (int i = 0; i < 18; i++) {

		this->draw_human(ofPoint(ofRandom(ofGetWidth() * -0.5, ofGetWidth() * 0.5), ofRandom(0, ofGetHeight() * 0.5), 80));
	}

	this->cam.end();
}

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

	ofSetColor(0, 0, 139);

	std::string words = "Ocean";
	ofPoint words_size = ofPoint(this->font.stringWidth(words), this->font.stringHeight(words));
	std::vector<ofPath> paths = this->font.getStringAsPoints(words, true, false);

	for (int x = ofGetWidth() * -0.8; x < ofGetWidth() * 0.8; x += words_size.x) {

		for (int y = 0; y < ofGetHeight(); y += words_size.y) {

			ofPoint words_center(x + words_size.x / 2, y - words_size.y / 2);
			for (int p_index = 0; p_index < paths.size(); p_index++) {

				vector<ofPolyline> outline = paths[p_index].getOutline();
				std::vector<ofPoint> points;
				for (int o_index = 0; o_index < outline.size(); o_index++) {

					if (o_index > 0) {

						ofNextContour(true);
					}

					outline[o_index] = outline[o_index].getResampledBySpacing(1);
					vector<glm::vec3> vertices = outline[o_index].getVertices();
					for (int v_index = 0; v_index < vertices.size(); v_index++) {

						ofPoint point = ofPoint(vertices[v_index].x, vertices[v_index].y, vertices[v_index].z) - words_center;
						float z = ofMap(ofNoise(point.x * 0.001, point.y * 0.005 - ofGetFrameNum() * 0.01), 0, 1, 0, 80);
						points.push_back(point + ofPoint(0, 0, z));
					}
				}

				if (points.size() > 0) {

					ofBeginShape();
					ofVertices(points);
					ofEndShape(true);
				}
			}
		}
	}
}

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

	ofSetColor(232, 202, 179);

	std::string words = "Beach";
	ofPoint words_size = ofPoint(this->font.stringWidth(words), this->font.stringHeight(words));
	std::vector<ofPath> paths = this->font.getStringAsPoints(words, true, false);

	for (int x = ofGetWidth() * -0.5; x < ofGetWidth() * 0.5; x += words_size.x) {

		for (int y = ofGetHeight() * -0.5; y < 0; y += words_size.y) {

			ofPoint words_center(x + words_size.x / 2, y - words_size.y / 2);
			for (int p_index = 0; p_index < paths.size(); p_index++) {

				vector<ofPolyline> outline = paths[p_index].getOutline();
				std::vector<ofPoint> points;
				for (int o_index = 0; o_index < outline.size(); o_index++) {

					if (o_index > 0) {

						ofNextContour(true);
					}

					outline[o_index] = outline[o_index].getResampledBySpacing(1);
					vector<glm::vec3> vertices = outline[o_index].getVertices();
					for (int v_index = 0; v_index < vertices.size(); v_index++) {

						ofPoint point = ofPoint(vertices[v_index].x, vertices[v_index].y, vertices[v_index].z) - words_center;
						points.push_back(point + ofPoint(0, 0, 80));
					}
				}

				if (points.size() > 0) {

					ofBeginShape();
					ofVertices(points);
					ofEndShape(true);
				}
			}
		}
	}
}

//--------------------------------------------------------------
void ofApp::draw_human(ofPoint point) {

	ofColor color;
	color.setHsb(ofRandom(255), 200, 255);
	ofSetColor(color);

	vector<string> words = {"H", "u", "m", "a", "n" };

	ofPushMatrix();
	ofTranslate(point);
	ofRotateX(270);

	for (int i = words.size() - 1; i > -1; i--) {

		this->font_small.drawString(words[i], this->font_small.stringWidth(words[i]) * -0.5, 0);

		float noise_value = ofMap(ofNoise(point.x * 0.005, point.y * 0.005, ofGetFrameNum() * 0.005), 0, 1, -5, 5);
		ofTranslate(noise_value, this->font_small.stringHeight(words[i]));
	}

	ofPopMatrix();
}

//--------------------------------------------------------------
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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofBackground(239);

ofSetWindowTitle("Insta");

ofEnableDepthTest();

this->font.loadFont("fonts/Kazesawa-Extrabold.ttf", 50, true, false, true);

this->font_small.loadFont("fonts/Kazesawa-Extrabold.ttf", 25, true, false, true);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

this->cam.begin();

ofRotateX(180);

this->draw_ocean();

this->draw_beach();

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

this->draw_human(ofPoint(ofRandom(ofGetWidth() * -0.5, ofGetWidth() * 0.5), ofRandom(0, ofGetHeight() * 0.5), 80));

}

this->cam.end();

}

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

void ofApp::draw_ocean() {

ofSetColor(0, 0, 139);

std::string words = "Ocean";

ofPoint words_size = ofPoint(this->font.stringWidth(words), this->font.stringHeight(words));

std::vector<ofPath> paths = this->font.getStringAsPoints(words, true, false);

for (int x = ofGetWidth() * -0.8; x < ofGetWidth() * 0.8; x += words_size.x) {

for (int y = 0; y < ofGetHeight(); y += words_size.y) {

ofPoint words_center(x + words_size.x / 2, y - words_size.y / 2);

for (int p_index = 0; p_index < paths.size(); p_index++) {

vector<ofPolyline> outline = paths[p_index].getOutline();

std::vector<ofPoint> points;

for (int o_index = 0; o_index < outline.size(); o_index++) {

if (o_index > 0) {

ofNextContour(true);

}

outline[o_index] = outline[o_index].getResampledBySpacing(1);

vector<glm::vec3> vertices = outline[o_index].getVertices();

for (int v_index = 0; v_index < vertices.size(); v_index++) {

ofPoint point = ofPoint(vertices[v_index].x, vertices[v_index].y, vertices[v_index].z) - words_center;

float z = ofMap(ofNoise(point.x * 0.001, point.y * 0.005 - ofGetFrameNum() * 0.01), 0, 1, 0, 80);

points.push_back(point + ofPoint(0, 0, z));

}

if (points.size() > 0) {

ofBeginShape();

ofVertices(points);

ofEndShape(true);

}

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

void ofApp::draw_beach() {

ofSetColor(232, 202, 179);

std::string words = "Beach";

ofPoint words_size = ofPoint(this->font.stringWidth(words), this->font.stringHeight(words));

std::vector<ofPath> paths = this->font.getStringAsPoints(words, true, false);

for (int x = ofGetWidth() * -0.5; x < ofGetWidth() * 0.5; x += words_size.x) {

for (int y = ofGetHeight() * -0.5; y < 0; y += words_size.y) {

ofPoint words_center(x + words_size.x / 2, y - words_size.y / 2);

for (int p_index = 0; p_index < paths.size(); p_index++) {

vector<ofPolyline> outline = paths[p_index].getOutline();

std::vector<ofPoint> points;

for (int o_index = 0; o_index < outline.size(); o_index++) {

if (o_index > 0) {

ofNextContour(true);

}

outline[o_index] = outline[o_index].getResampledBySpacing(1);

vector<glm::vec3> vertices = outline[o_index].getVertices();

for (int v_index = 0; v_index < vertices.size(); v_index++) {

ofPoint point = ofPoint(vertices[v_index].x, vertices[v_index].y, vertices[v_index].z) - words_center;

points.push_back(point + ofPoint(0, 0, 80));

}

if (points.size() > 0) {

ofBeginShape();

ofVertices(points);

ofEndShape(true);

}

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

void ofApp::draw_human(ofPoint point) {

ofColor color;

color.setHsb(ofRandom(255), 200, 255);

ofSetColor(color);

vector<string> words = {"H", "u", "m", "a", "n" };

ofPushMatrix();

ofTranslate(point);

ofRotateX(270);

for (int i = words.size() - 1; i > -1; i--) {

this->font_small.drawString(words[i], this->font_small.stringWidth(words[i]) * -0.5, 0);

float noise_value = ofMap(ofNoise(point.x * 0.005, point.y * 0.005, ofGetFrameNum() * 0.005), 0, 1, -5, 5);

ofTranslate(noise_value, this->font_small.stringHeight(words[i]));

}

ofPopMatrix();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年7月2日2018年7月2日

360度動画 openFrameworks

[ Video ]

[ About ]
動画の細切れにして円周上に配置、再生フレームと角度をリンクさせたらフィルムみたいになって綺麗じゃね？って思ったら、全然そんな事なかったので、ズラっと並べてました

[ 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;
	int number_of_frames;

	vector<cv::Mat> cap_frames;
	vector<cv::Mat> frames;
	vector<ofImage*> images;
};

#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;

int number_of_frames;

vector<cv::Mat> cap_frames;

vector<cv::Mat> frames;

vector<ofImage*> images;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("Insta");

	ofBackground(239);
	ofEnableDepthTest();
	ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

	this->cap.open("D:\\video\\image11.mp4");
	this->cap_size = cv::Size(160, 90);

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

		ofImage* image = new ofImage();
		image->allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
		this->images.push_back(image);

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

	this->number_of_frames = this->cap.get(CV_CAP_PROP_FRAME_COUNT);
	for (int i = 0; i < number_of_frames; i++) {

		cv::Mat src, mini_src;
		this->cap >> src;
		cv::resize(src, mini_src, this->cap_size);
		cv::cvtColor(mini_src, mini_src, CV_BGR2RGB);

		this->cap_frames.push_back(mini_src);
	}
}

//--------------------------------------------------------------
void ofApp::update() {
	
	int capture_span = this->number_of_frames / 36;
	for (int i = 0; i < this->frames.size(); i++) {

		int index = (ofGetFrameNum() + i * capture_span) % this->number_of_frames;
		this->cap_frames[index].copyTo(this->frames[i]);

		this->images[i]->update();
	}
}

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

	this->cam.begin();

	int radius = 500;
	for(int i = 0; i < this->images.size(); i++){
		 
		int deg = i * 10;
		ofPoint point(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));

		ofPushMatrix();
		ofTranslate(point);
		ofRotateY(90);
		ofRotateY(45);

		this->images[i]->draw(0, 0);

		ofPopMatrix();
	}

	this->cam.end();
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("Insta");

ofBackground(239);

ofEnableDepthTest();

ofSetRectMode(ofRectMode::OF_RECTMODE_CENTER);

this->cap.open("D:\\video\\image11.mp4");

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

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

ofImage* image = new ofImage();

image->allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);

this->images.push_back(image);

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

this->frames.push_back(frame);

}

this->number_of_frames = this->cap.get(CV_CAP_PROP_FRAME_COUNT);

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

cv::Mat src, mini_src;

this->cap >> src;

cv::resize(src, mini_src, this->cap_size);

cv::cvtColor(mini_src, mini_src, CV_BGR2RGB);

this->cap_frames.push_back(mini_src);

}

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

void ofApp::update() {

int capture_span = this->number_of_frames / 36;

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

int index = (ofGetFrameNum() + i * capture_span) % this->number_of_frames;

this->cap_frames[index].copyTo(this->frames[i]);

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

}

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

void ofApp::draw() {

this->cam.begin();

int radius = 500;

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

int deg = i * 10;

ofPoint point(radius * cos(deg * DEG_TO_RAD), radius * sin(deg * DEG_TO_RAD));

ofPushMatrix();

ofTranslate(point);

ofRotateY(90);

ofRotateY(45);

this->images[i]->draw(0, 0);

ofPopMatrix();

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2024年11月
月	火	水	木	金	土	日
				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