opencv – ページ 32 – プログラミング de 落描き

2018年8月30日

Pixel processing by shader. openframeworks

[ Video ]

[ About ]
動画の10フレーム分をテキスチャとしてシェーダに送信、ピクセルごとにノイズで描写フレームを操作。OpenCVでも何度か似た処理をやってきたけど、こちらの方が早くて素敵。

Send 10 frames of video to shader. Pixel drawing frame is determinated by 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 mouseEntered(int x, int y) {};
	void mouseExited(int x, int y) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	cv::VideoCapture cap;
	cv::Size cap_size;
	vector<cv::Mat> frames;
	vector<ofImage> images;

	ofFbo src;
	ofFbo dst;

	ofShader shader;
};

#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 mouseEntered(int x, int y) {};

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

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

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

cv::VideoCapture cap;

cv::Size cap_size;

vector<cv::Mat> frames;

vector<ofImage> images;

ofFbo src;

ofFbo dst;

ofShader shader;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("openframeworks");

	this->cap.open("image1.mp4");
	this->cap_size = cv::Size(1280, 720);

	cv::Mat cap_frame;
	while(true){

		this->cap >> cap_frame;
		if (cap_frame.empty()) {

			break;
		}

		ofImage image;
		image.allocate(this->cap_size.width, this->cap_size.height, 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::resize(cap_frame, cap_frame, this->cap_size);
		cv::cvtColor(cap_frame, cap_frame, CV_BGR2RGB);
		cap_frame.copyTo(frame);
	
		this->frames.push_back(frame);
		this->images.push_back(image);
	}
	
	this->src.allocate(ofGetWidth(), ofGetHeight());
	this->dst.allocate(ofGetWidth(), ofGetHeight());

	this->shader.load("shader/shader.vert", "shader/shader.frag");

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

}

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

	int frame_number = ofGetFrameNum() % this->images.size();

	this->dst.begin();
	ofClear(0);

	this->shader.begin();
	this->shader.setUniform1f("time", ofGetElapsedTimef());
	this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());
	this->shader.setUniformTexture("tex0", this->images[(frame_number + 0) % this->images.size()], 1);
	this->shader.setUniformTexture("tex1", this->images[(frame_number + 2) % this->images.size()], 2);
	this->shader.setUniformTexture("tex2", this->images[(frame_number + 4) % this->images.size()], 3);
	this->shader.setUniformTexture("tex3", this->images[(frame_number + 6) % this->images.size()], 4);
	this->shader.setUniformTexture("tex4", this->images[(frame_number + 8) % this->images.size()], 5);
	this->shader.setUniformTexture("tex5", this->images[(frame_number + 10) % this->images.size()], 5);
	this->shader.setUniformTexture("tex6", this->images[(frame_number + 12) % this->images.size()], 5);
	this->shader.setUniformTexture("tex7", this->images[(frame_number + 14) % this->images.size()], 5);
	this->shader.setUniformTexture("tex8", this->images[(frame_number + 16) % this->images.size()], 5);
	this->shader.setUniformTexture("tex9", this->images[(frame_number + 18) % this->images.size()], 5);
	this->src.draw(0, 0);
	this->shader.end();

	this->dst.end();

	ofSetColor(255);
	this->dst.draw(0, 0);

}

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

	ofGLWindowSettings settings;
	settings.setGLVersion(3, 2);
	settings.setSize(1280, 720);
	ofCreateWindow(settings);
	ofRunApp(new ofApp());
}

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

this->cap.open("image1.mp4");

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

cv::Mat cap_frame;

while(true){

this->cap >> cap_frame;

if (cap_frame.empty()) {

break;

}

ofImage image;

image.allocate(this->cap_size.width, this->cap_size.height, 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::resize(cap_frame, cap_frame, this->cap_size);

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

cap_frame.copyTo(frame);

this->frames.push_back(frame);

this->images.push_back(image);

}

this->src.allocate(ofGetWidth(), ofGetHeight());

this->dst.allocate(ofGetWidth(), ofGetHeight());

this->shader.load("shader/shader.vert", "shader/shader.frag");

}

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

void ofApp::update() {

}

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

void ofApp::draw() {

int frame_number = ofGetFrameNum() % this->images.size();

this->dst.begin();

ofClear(0);

this->shader.begin();

this->shader.setUniform1f("time", ofGetElapsedTimef());

this->shader.setUniform2f("resolution", ofGetWidth(), ofGetHeight());

this->shader.setUniformTexture("tex0", this->images[(frame_number + 0) % this->images.size()], 1);

this->shader.setUniformTexture("tex1", this->images[(frame_number + 2) % this->images.size()], 2);

this->shader.setUniformTexture("tex2", this->images[(frame_number + 4) % this->images.size()], 3);

this->shader.setUniformTexture("tex3", this->images[(frame_number + 6) % this->images.size()], 4);

this->shader.setUniformTexture("tex4", this->images[(frame_number + 8) % this->images.size()], 5);

this->shader.setUniformTexture("tex5", this->images[(frame_number + 10) % this->images.size()], 5);

this->shader.setUniformTexture("tex6", this->images[(frame_number + 12) % this->images.size()], 5);

this->shader.setUniformTexture("tex7", this->images[(frame_number + 14) % this->images.size()], 5);

this->shader.setUniformTexture("tex8", this->images[(frame_number + 16) % this->images.size()], 5);

this->shader.setUniformTexture("tex9", this->images[(frame_number + 18) % this->images.size()], 5);

this->src.draw(0, 0);

this->shader.end();

this->dst.end();

ofSetColor(255);

this->dst.draw(0, 0);

}

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

int main() {

ofGLWindowSettings settings;

settings.setGLVersion(3, 2);

settings.setSize(1280, 720);

ofCreateWindow(settings);

ofRunApp(new ofApp());

}

#version 150

uniform mat4 modelViewProjectionMatrix;

in vec4 position;
in vec2 texcoord;

out vec2 texCoordVarying;

void main(){

	texCoordVarying = texcoord;
	gl_Position = modelViewProjectionMatrix * position;
}

#version 150

uniform mat4 modelViewProjectionMatrix;

in vec4 position;

in vec2 texcoord;

out vec2 texCoordVarying;

void main(){

texCoordVarying = texcoord;

gl_Position = modelViewProjectionMatrix * position;

}

#version 150

uniform float time;
uniform vec2 resolution;
uniform sampler2DRect tex0;
uniform sampler2DRect tex1;
uniform sampler2DRect tex2;
uniform sampler2DRect tex3;
uniform sampler2DRect tex4;
uniform sampler2DRect tex5;
uniform sampler2DRect tex6;
uniform sampler2DRect tex7;
uniform sampler2DRect tex8;
uniform sampler2DRect tex9;

in vec2 texCoordVarying;

out vec4 outputColor;

float mod289(float x){return x - floor(x * (1.0 / 289.0)) * 289.0;}
vec4 mod289(vec4 x){return x - floor(x * (1.0 / 289.0)) * 289.0;}
vec4 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}

float noise(vec3 p){
    vec3 a = floor(p);
    vec3 d = p - a;
    d = d * d * (3.0 - 2.0 * d);

    vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
    vec4 k1 = perm(b.xyxy);
    vec4 k2 = perm(k1.xyxy + b.zzww);

    vec4 c = k2 + a.zzzz;
    vec4 k3 = perm(c);
    vec4 k4 = perm(c + 1.0);

    vec4 o1 = fract(k3 * (1.0 / 41.0));
    vec4 o2 = fract(k4 * (1.0 / 41.0));

    vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
    vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);

    return o4.y * d.y + o4.x * (1.0 - d.y);
}

void main() {

  vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);

  vec4 color = vec4(0.0);
  float v = noise(vec3(p.x * 13.0, p.y * 13.0, time));

  if(v < 0.1){
    color += texture(tex0, texCoordVarying);
  }else if(v < 0.2){
    color += texture(tex1, texCoordVarying);
  }else if(v < 0.3){
    color += texture(tex2, texCoordVarying);
  }else if(v < 0.4){
    color += texture(tex3, texCoordVarying);
  }else if(v < 0.5){
    color += texture(tex4, texCoordVarying);
  }else if(v < 0.6){
    color += texture(tex5, texCoordVarying);
  }else if(v < 0.7){
    color += texture(tex6, texCoordVarying);
  }else if(v < 0.8){
    color += texture(tex7, texCoordVarying);
  }else if(v < 0.9){
    color += texture(tex8, texCoordVarying);
  }else {
    color += texture(tex9, texCoordVarying);
  }

  outputColor = color;
}

#version 150

uniform float time;

uniform vec2 resolution;

uniform sampler2DRect tex0;

uniform sampler2DRect tex1;

uniform sampler2DRect tex2;

uniform sampler2DRect tex3;

uniform sampler2DRect tex4;

uniform sampler2DRect tex5;

uniform sampler2DRect tex6;

uniform sampler2DRect tex7;

uniform sampler2DRect tex8;

uniform sampler2DRect tex9;

in vec2 texCoordVarying;

out vec4 outputColor;

float mod289(float x){return x - floor(x * (1.0 / 289.0)) * 289.0;}

vec4 mod289(vec4 x){return x - floor(x * (1.0 / 289.0)) * 289.0;}

vec4 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}

float noise(vec3 p){

vec3 a = floor(p);

vec3 d = p - a;

d = d * d * (3.0 - 2.0 * d);

vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);

vec4 k1 = perm(b.xyxy);

vec4 k2 = perm(k1.xyxy + b.zzww);

vec4 c = k2 + a.zzzz;

vec4 k3 = perm(c);

vec4 k4 = perm(c + 1.0);

vec4 o1 = fract(k3 * (1.0 / 41.0));

vec4 o2 = fract(k4 * (1.0 / 41.0));

vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);

vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);

return o4.y * d.y + o4.x * (1.0 - d.y);

}

void main() {

vec2 p = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);

vec4 color = vec4(0.0);

float v = noise(vec3(p.x * 13.0, p.y * 13.0, time));

if(v < 0.1){

color += texture(tex0, texCoordVarying);

}else if(v < 0.2){

color += texture(tex1, texCoordVarying);

}else if(v < 0.3){

color += texture(tex2, texCoordVarying);

}else if(v < 0.4){

color += texture(tex3, texCoordVarying);

}else if(v < 0.5){

color += texture(tex4, texCoordVarying);

}else if(v < 0.6){

color += texture(tex5, texCoordVarying);

}else if(v < 0.7){

color += texture(tex6, texCoordVarying);

}else if(v < 0.8){

color += texture(tex7, texCoordVarying);

}else if(v < 0.9){

color += texture(tex8, texCoordVarying);

}else {

color += texture(tex9, texCoordVarying);

}

outputColor = color;

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年8月16日2018年8月16日

Color to frame difference. openframeworks

[ Video ]

[ About ]
フレーム差分に対して着色

Color to frame difference.

[ 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 mouseEntered(int x, int y) {};
	void mouseExited(int x, int y) {};
	void windowResized(int w, int h) {};
	void dragEvent(ofDragInfo dragInfo) {};
	void gotMessage(ofMessage msg) {};

	cv::VideoCapture cap;
	cv::Size cap_size;
	vector<cv::Mat> cap_frames;
	vector<unique_ptr<ofImage>> images;

	cv::Mat blend_frame;
	ofImage blend_image;
};

#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 mouseEntered(int x, int y) {};

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

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

void dragEvent(ofDragInfo dragInfo) {};

void gotMessage(ofMessage msg) {};

cv::VideoCapture cap;

cv::Size cap_size;

vector<cv::Mat> cap_frames;

vector<unique_ptr<ofImage>> images;

cv::Mat blend_frame;

ofImage blend_image;

};

#include "ofApp.h"

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

	ofSetFrameRate(30);
	ofSetWindowTitle("openframeworks");

	ofBackground(0);

	this->cap.open("D:\\video\\image26.mp4");
	this->cap_size = cv::Size(1280, 720);

	cv::Mat cap_frame;
	while (true) {

		this->cap >> cap_frame;
		if (cap_frame.empty()) { 
			
			break; 
		}

		cv::resize(cap_frame, cap_frame, this->cap_size);
		cv::cvtColor(cap_frame, cap_frame, CV_BGR2RGB);
		this->cap_frames.push_back(cap_frame);

		unique_ptr<ofImage> image(new ofImage());
		image->allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
		this->images.push_back(move(image));
	}

	this->blend_image.allocate(this->cap_size.width, this->cap_size.height, OF_IMAGE_COLOR);
	this->blend_frame = cv::Mat(this->blend_image.getHeight(), this->blend_image.getWidth(), CV_MAKETYPE(CV_8UC3, this->blend_image.getPixels().getNumChannels()), this->blend_image.getPixels().getData(), 0);
}

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

	int blend_count = 5;
	int frame_span = 1;
	cv::Mat diff, gray_diff, color_diff;

	this->blend_frame = this->cap_frames[(ofGetFrameNum() + blend_count * frame_span) % this->cap_frames.size()] * 1.0;
	for (int i = 0; i < blend_count; i++) {
	
		cv::absdiff(this->cap_frames[(ofGetFrameNum() + i * frame_span) % this->cap_frames.size()], this->cap_frames[(ofGetFrameNum() + (i + 1) * frame_span) % this->cap_frames.size()], diff);
		cv::cvtColor(diff, gray_diff, CV_RGB2GRAY);
		cv::threshold(gray_diff, gray_diff, 64, 255, CV_THRESH_BINARY);

		cv::applyColorMap(diff, color_diff, cv::COLORMAP_HSV);

		/*
		cv::imshow("diff", diff);
		cv::imshow("gray_diff", gray_diff);
		cv::imshow("color_diff", color_diff);
		cv::waitKey(1);
		*/

		cv::add(this->blend_frame, diff, this->blend_frame, gray_diff);
	}
}

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

	ofSetColor(255);
	this->blend_image.update();
	this->blend_image.draw(0, 0);
}

//--------------------------------------------------------------
int main() {
	ofSetupOpenGL(1280, 720, OF_WINDOW);
	ofRunApp(new ofApp());
}

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openframeworks");

ofBackground(0);

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

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

cv::Mat cap_frame;

while (true) {

this->cap >> cap_frame;

if (cap_frame.empty()) {

break;

}

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

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

this->cap_frames.push_back(cap_frame);

unique_ptr<ofImage> image(new ofImage());

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

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

}

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

this->blend_frame = cv::Mat(this->blend_image.getHeight(), this->blend_image.getWidth(), CV_MAKETYPE(CV_8UC3, this->blend_image.getPixels().getNumChannels()), this->blend_image.getPixels().getData(), 0);

}

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

void ofApp::update() {

int blend_count = 5;

int frame_span = 1;

cv::Mat diff, gray_diff, color_diff;

this->blend_frame = this->cap_frames[(ofGetFrameNum() + blend_count * frame_span) % this->cap_frames.size()] * 1.0;

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

cv::absdiff(this->cap_frames[(ofGetFrameNum() + i * frame_span) % this->cap_frames.size()], this->cap_frames[(ofGetFrameNum() + (i + 1) * frame_span) % this->cap_frames.size()], diff);

cv::cvtColor(diff, gray_diff, CV_RGB2GRAY);

cv::threshold(gray_diff, gray_diff, 64, 255, CV_THRESH_BINARY);

cv::applyColorMap(diff, color_diff, cv::COLORMAP_HSV);

cv::imshow("diff", diff);

cv::imshow("gray_diff", gray_diff);

cv::imshow("color_diff", color_diff);

cv::waitKey(1);

cv::add(this->blend_frame, diff, this->blend_frame, gray_diff);

}

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

void ofApp::draw() {

ofSetColor(255);

this->blend_image.update();

this->blend_image.draw(0, 0);

}

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

int main() {

ofSetupOpenGL(1280, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2018年7月26日2018年7月26日

Divided video. openframeworks

[ Video ]

[ About ]
バラバラ動画

Divided video.

[ Source ]

#pragma once
#include "ofMain.h"
#include "ofxBox2d.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) {};

	ofFbo fbo;
	bool enable_gravity;

	ofxBox2d box2d;
	vector<shared_ptr<ofxBox2dRect>> rects;

	cv::VideoCapture cap;
	cv::Size cap_size;

	float rect_size;
	vector<cv::Mat> frames;
	vector<unique_ptr<ofImage>> images;
	vector<cv::Rect> cv_rects;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.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) {};

ofFbo fbo;

bool enable_gravity;

ofxBox2d box2d;

vector<shared_ptr<ofxBox2dRect>> rects;

cv::VideoCapture cap;

cv::Size cap_size;

float rect_size;

vector<cv::Mat> frames;

vector<unique_ptr<ofImage>> images;

vector<cv::Rect> cv_rects;

};

#include "ofApp.h"

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

	ofBackground(39);
	ofSetWindowTitle("openframeworks");

	this->cap.open("D:\\video\\image.mp4");
	this->cap_size = cv::Size(1280, 720);
	ofSetFrameRate(this->cap.get(CV_CAP_PROP_FPS));

	this->box2d.init();
	this->box2d.setGravity(0, 0);
	this->box2d.createBounds();
	this->box2d.setFPS(30);
	this->box2d.registerGrabbing();

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

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

			ofPoint start_point(x + ofGetWidth() * 0.5 - this->cap_size.width * 0.5, y + ofGetHeight() * 0.5 - this->cap_size.height * 0.5);

			this->rects.push_back(shared_ptr<ofxBox2dRect>(new ofxBox2dRect));
			this->rects.back().get()->setPhysics(1.0, 0.63, 0.1);
			this->rects.back().get()->setup(this->box2d.getWorld(), start_point.x, start_point.y, this->rect_size, this->rect_size);

			unique_ptr<ofImage> image(new 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);
			this->images.push_back(std::move(image));
			this->frames.push_back(frame);

			cv::Rect rect = cv::Rect(x, y, this->rect_size, this->rect_size);
			this->cv_rects.push_back(rect);
		}
	}

	this->fbo.allocate(ofGetWidth(), ofGetHeight());
}

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

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

		cap.set(CV_CAP_PROP_POS_FRAMES, 1);
		return;
	}

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


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

		cv::Mat tmp_box_image(frame, this->cv_rects[i]);
		tmp_box_image.copyTo(this->frames[i]);
		this->images[i]->update();
	}

	if (this->enable_gravity == false) {

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

			for (int j = i + 1; j < this->rects.size(); j++) {

				float distance = this->rects[i]->getPosition().distance(this->rects[j]->getPosition());
				if (distance < 33) {

					this->rects[i]->addForce(this->rects[i]->getPosition() - this->rects[j]->getPosition(), 0.5);
					this->rects[j]->addForce(this->rects[j]->getPosition() - this->rects[i]->getPosition(), 0.5);
				}
			}
		}
	}

	this->box2d.update();

	this->fbo.begin();
	ofClear(0);

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

		ofPushMatrix();
		ofTranslate(this->rects[i].get()->getPosition().x, this->rects[i].get()->getPosition().y);
		ofRotate(this->rects[i].get()->getRotation());

		this->images[i]->draw(-this->rect_size / 2, -this->rect_size / 2);

		ofPopMatrix();
	}

	this->fbo.end();
}

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

	this->fbo.draw(0, 0);
}

//--------------------------------------------------------------
void ofApp::keyPressed(int key)
{
	if (key == 't') {

		this->box2d.setGravity(0, 10);
		this->enable_gravity = true;
	}
	else if (key == 'f') {

		this->box2d.setGravity(0, 0);
		this->enable_gravity = false;
	}

}

//========================================================================
int main() {

	ofSetupOpenGL(1280, 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

#include "ofApp.h"

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

void ofApp::setup() {

ofBackground(39);

ofSetWindowTitle("openframeworks");

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

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

ofSetFrameRate(this->cap.get(CV_CAP_PROP_FPS));

this->box2d.init();

this->box2d.setGravity(0, 0);

this->box2d.createBounds();

this->box2d.setFPS(30);

this->box2d.registerGrabbing();

this->rect_size = 30;

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

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

ofPoint start_point(x + ofGetWidth() * 0.5 - this->cap_size.width * 0.5, y + ofGetHeight() * 0.5 - this->cap_size.height * 0.5);

this->rects.push_back(shared_ptr<ofxBox2dRect>(new ofxBox2dRect));

this->rects.back().get()->setPhysics(1.0, 0.63, 0.1);

this->rects.back().get()->setup(this->box2d.getWorld(), start_point.x, start_point.y, this->rect_size, this->rect_size);

unique_ptr<ofImage> image(new 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);

this->images.push_back(std::move(image));

this->frames.push_back(frame);

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

this->cv_rects.push_back(rect);

}

this->fbo.allocate(ofGetWidth(), ofGetHeight());

}

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

void ofApp::update() {

cv::Mat src, frame;

this->cap >> src;

if (src.empty()) {

cap.set(CV_CAP_PROP_POS_FRAMES, 1);

return;

}

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

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

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

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

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

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

}

if (this->enable_gravity == false) {

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

for (int j = i + 1; j < this->rects.size(); j++) {

float distance = this->rects[i]->getPosition().distance(this->rects[j]->getPosition());

if (distance < 33) {

this->rects[i]->addForce(this->rects[i]->getPosition() - this->rects[j]->getPosition(), 0.5);

this->rects[j]->addForce(this->rects[j]->getPosition() - this->rects[i]->getPosition(), 0.5);

}

this->box2d.update();

this->fbo.begin();

ofClear(0);

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

ofPushMatrix();

ofTranslate(this->rects[i].get()->getPosition().x, this->rects[i].get()->getPosition().y);

ofRotate(this->rects[i].get()->getRotation());

this->images[i]->draw(-this->rect_size / 2, -this->rect_size / 2);

ofPopMatrix();

}

this->fbo.end();

}

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

void ofApp::draw() {

this->fbo.draw(0, 0);

}

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

void ofApp::keyPressed(int key)

{

if (key == 't') {

this->box2d.setGravity(0, 10);

this->enable_gravity = true;

}

else if (key == 'f') {

this->box2d.setGravity(0, 0);

this->enable_gravity = false;

}

//========================================================================

int main() {

ofSetupOpenGL(1280, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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