mouse – ページ 2 – プログラミング de 落描き

2017年11月17日2017年12月5日

Insta20171116

[ Video ]

[ About ]
openFrameworksで手書きした絵を、Yolo v2で判別しています。

Yolo v2 classifies handwritten pictures written by openFrameworks.

[ Source ]

#include "ofMain.h"

// OpenCV 3.3.1
#include <opencv2/dnn.hpp>
#include <opencv2/dnn/shape_utils.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
using namespace cv::dnn;

class ofApp : public ofBaseApp {

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

	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) {};

	vector<ofPolyline> lines;
	int line_index;
	ofImage dog_image;

	cv::Mat frame;
	ofImage frame_image;
	cv::VideoCapture cap;

	const size_t network_width = 416;
	const size_t network_height = 416;

	String modelConfiguration = "yolo.cfg";
	String modelBinary = "yolo.weights";

	dnn::Net net;
	cv::Mat resized, inputBlob, detectionMat;

	const vector<string> class_names = { "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
		"truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",
		"bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",
		"zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",
		"frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",
		"baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
		"wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
		"sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",
		"cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",
		"tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",
		"oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors",
		"teddy bear", "hair drier", "toothbrush" };
};

#include "ofMain.h"

// OpenCV 3.3.1

#include <opencv2/dnn.hpp>

#include <opencv2/dnn/shape_utils.hpp>

#include <opencv2/imgproc.hpp>

#include <opencv2/highgui.hpp>

using namespace cv;

using namespace cv::dnn;

class ofApp : public ofBaseApp {

public:

void setup();

void update();

void draw();

void detection();

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) {};

vector<ofPolyline> lines;

int line_index;

ofImage dog_image;

cv::Mat frame;

ofImage frame_image;

cv::VideoCapture cap;

const size_t network_width = 416;

const size_t network_height = 416;

String modelConfiguration = "yolo.cfg";

String modelBinary = "yolo.weights";

dnn::Net net;

cv::Mat resized, inputBlob, detectionMat;

const vector<string> class_names = { "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",

"truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter",

"bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear",

"zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase",

"frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat",

"baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",

"wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",

"sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut",

"cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet",

"tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave",

"oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors",

"teddy bear", "hair drier", "toothbrush" };

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {
	ofSetFrameRate(60);
	ofBackground(255);
	ofSetWindowTitle("Insta");

	ofNoFill();

	this->frame_image.allocate(ofGetWidth(), ofGetHeight(), OF_IMAGE_COLOR);
	this->frame = cv::Mat(this->frame_image.getHeight(), this->frame_image.getWidth(), CV_MAKETYPE(CV_8UC3, this->frame_image.getPixels().getNumChannels()), this->frame_image.getPixels().getData(), 0);

	this->dog_image.load("dog.jpg");

	this->net = readNetFromDarknet(modelConfiguration, modelBinary);
	if (net.empty()) {
		cout << "dnn Net is empty" << endl;
	}

	this->line_index = 0;
}

//--------------------------------------------------------------
void ofApp::update() {
	if (ofGetMousePressed()) {
		this->lines[this->line_index].addVertex(ofGetMouseX(), ofGetMouseY());
	}
}

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

	ofSetColor(0);
	for (int i = 0; i < this->lines.size(); i++) {
		this->lines[i].draw();
	}

	ofSetColor(255);
	this->dog_image.draw(0, ofGetHeight() / 2 - this->dog_image.getHeight() / 2);

	this->frame_image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
	cv::cvtColor(this->frame, this->frame, CV_BGR2RGB);

	if (!this->frame.empty()) {
		this->detection();
	}

	cv::imshow("frame", this->frame);
	cv::waitKey(1);
}

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

	cv::resize(this->frame, this->resized, cv::Size(this->network_width, this->network_height));
	this->inputBlob = blobFromImage(this->resized, 1 / 255.F);		//Convert Mat to batch of images
	this->net.setInput(this->inputBlob, "data");					//set the network input
	this->detectionMat = this->net.forward("detection_out");		//compute output

	float confidenceThreshold = 0.15;
	for (int i = 0; i < detectionMat.rows; i++)
	{
		const int probability_index = 5;
		const int probability_size = detectionMat.cols - probability_index;
		float *prob_array_ptr = &detectionMat.at<float>(i, probability_index);

		size_t objectClass = std::max_element(prob_array_ptr, prob_array_ptr + probability_size) - prob_array_ptr;
		float confidence = detectionMat.at<float>(i, (int)objectClass + probability_index);

		if (confidence > confidenceThreshold)
		{
			float x = detectionMat.at<float>(i, 0);
			float y = detectionMat.at<float>(i, 1);
			float width = detectionMat.at<float>(i, 2);
			float height = detectionMat.at<float>(i, 3);
			float xLeftBottom = (x - width / 2) * frame.cols;
			float yLeftBottom = (y - height / 2) * frame.rows;
			float xRightTop = (x + width / 2) * frame.cols;
			float yRightTop = (y + height / 2) * frame.rows;

			cv::Rect object(
				(int)xLeftBottom,
				(int)yLeftBottom,
				(int)(xRightTop - xLeftBottom),
				(int)(yRightTop - yLeftBottom));

			cv::Rect title(
				(int)xLeftBottom,
				(int)yLeftBottom - 15,
				100,
				15);

			std::string object_name = "";
			if (objectClass < class_names.size()) {
				object_name = class_names[objectClass];
			}
			cv::rectangle(frame, title, Scalar(0, 255, 0), -1);
			cv::putText(frame, object_name, cv::Point((int)xLeftBottom, (int)yLeftBottom - 2), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255), 2);
			cv::rectangle(frame, object, Scalar(0, 255, 0));
		}
	}
}

//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
	this->lines.push_back(ofPolyline());
}

//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button) {
	this->line_index += 1;
}

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

ofBackground(255);

ofSetWindowTitle("Insta");

ofNoFill();

this->frame_image.allocate(ofGetWidth(), ofGetHeight(), OF_IMAGE_COLOR);

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

this->dog_image.load("dog.jpg");

this->net = readNetFromDarknet(modelConfiguration, modelBinary);

if (net.empty()) {

cout << "dnn Net is empty" << endl;

}

this->line_index = 0;

}

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

void ofApp::update() {

if (ofGetMousePressed()) {

this->lines[this->line_index].addVertex(ofGetMouseX(), ofGetMouseY());

}

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

void ofApp::draw() {

ofSetColor(0);

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

this->lines[i].draw();

}

ofSetColor(255);

this->dog_image.draw(0, ofGetHeight() / 2 - this->dog_image.getHeight() / 2);

this->frame_image.grabScreen(0, 0, ofGetWidth(), ofGetHeight());

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

if (!this->frame.empty()) {

this->detection();

}

cv::imshow("frame", this->frame);

cv::waitKey(1);

}

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

void ofApp::detection() {

cv::resize(this->frame, this->resized, cv::Size(this->network_width, this->network_height));

this->inputBlob = blobFromImage(this->resized, 1 / 255.F); //Convert Mat to batch of images

this->net.setInput(this->inputBlob, "data"); //set the network input

this->detectionMat = this->net.forward("detection_out"); //compute output

float confidenceThreshold = 0.15;

for (int i = 0; i < detectionMat.rows; i++)

{

const int probability_index = 5;

const int probability_size = detectionMat.cols - probability_index;

float *prob_array_ptr = &detectionMat.at<float>(i, probability_index);

size_t objectClass = std::max_element(prob_array_ptr, prob_array_ptr + probability_size) - prob_array_ptr;

float confidence = detectionMat.at<float>(i, (int)objectClass + probability_index);

if (confidence > confidenceThreshold)

{

float x = detectionMat.at<float>(i, 0);

float y = detectionMat.at<float>(i, 1);

float width = detectionMat.at<float>(i, 2);

float height = detectionMat.at<float>(i, 3);

float xLeftBottom = (x - width / 2) * frame.cols;

float yLeftBottom = (y - height / 2) * frame.rows;

float xRightTop = (x + width / 2) * frame.cols;

float yRightTop = (y + height / 2) * frame.rows;

cv::Rect object(

(int)xLeftBottom,

(int)yLeftBottom,

(int)(xRightTop - xLeftBottom),

(int)(yRightTop - yLeftBottom));

cv::Rect title(

(int)xLeftBottom,

(int)yLeftBottom - 15,

100,

15);

std::string object_name = "";

if (objectClass < class_names.size()) {

object_name = class_names[objectClass];

}

cv::rectangle(frame, title, Scalar(0, 255, 0), -1);

cv::putText(frame, object_name, cv::Point((int)xLeftBottom, (int)yLeftBottom - 2), cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(255), 2);

cv::rectangle(frame, object, Scalar(0, 255, 0));

}

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

void ofApp::mousePressed(int x, int y, int button){

this->lines.push_back(ofPolyline());

}

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

void ofApp::mouseReleased(int x, int y, int button) {

this->line_index += 1;

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2017年11月15日2017年12月5日

Insta20171114

[ Video ]

[ About ]
マウスからパーティクルが逃げる機構を追加しました。
次はLeapMotionかな。

Added movement of particles escaping from the mouse.
Next is LeapMotion’s turn.

[ Source ]

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

	vector<shared_ptr<Particle>> particles;
};

#pragma once

#include "ofMain.h"

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

vector<shared_ptr<Particle>> particles;

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup() {
	ofSetFrameRate(60);
	ofBackground(0);
	ofSetWindowTitle("Insta");

	ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

	for (int i = 0; i < 1024; i++) {
		this->particles.push_back(shared_ptr<Particle>(new Particle()));
	}
}

//--------------------------------------------------------------
void ofApp::update() {
	for (int i = 0; i < this->particles.size(); i++) {
		if (ofGetMousePressed()) {
			ofVec2f mouse_point = ofVec2f(ofGetMouseX(), ofGetMouseY());
			ofVec2f distance = this->particles[i]->get_location() - mouse_point;

			if (distance.length() < 150) {
				this->particles[i]->apply_force(distance.limit(5));
			}
		}
		this->particles[i]->update();
	}
}

//--------------------------------------------------------------
void ofApp::draw() {
	for (int i = 0; i < this->particles.size(); i++) {
		this->particles[i]->draw(this->particles);
	}
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofBackground(0);

ofSetWindowTitle("Insta");

ofEnableBlendMode(ofBlendMode::OF_BLENDMODE_ADD);

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

this->particles.push_back(shared_ptr<Particle>(new Particle()));

}

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

void ofApp::update() {

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

if (ofGetMousePressed()) {

ofVec2f mouse_point = ofVec2f(ofGetMouseX(), ofGetMouseY());

ofVec2f distance = this->particles[i]->get_location() - mouse_point;

if (distance.length() < 150) {

this->particles[i]->apply_force(distance.limit(5));

}

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

}

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

void ofApp::draw() {

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

this->particles[i]->draw(this->particles);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

#pragma once
#include "ofMain.h"

class Particle
{
public:
	Particle();
	~Particle() {};

	void apply_force(ofVec2f force);
	void update();
	void draw(vector<shared_ptr<Particle>> particles);

	ofVec2f get_location();
private:
	ofVec2f location;
	ofVec2f velocity;
	ofVec2f acceleration;
	ofColor body_color;
};

#pragma once

#include "ofMain.h"

class Particle

{

public:

Particle();

~Particle() {};

void apply_force(ofVec2f force);

void update();

void draw(vector<shared_ptr<Particle>> particles);

ofVec2f get_location();

private:

ofVec2f location;

ofVec2f velocity;

ofVec2f acceleration;

ofColor body_color;

};

#include "Particle.h"

Particle::Particle() {
	this->location = ofVec2f(ofRandom(ofGetWidth()), ofRandom(ofGetHeight()));
	this->velocity = ofVec2f(ofRandom(-2, 2), ofRandom(-2, 2));
	this->acceleration = ofVec2f();
	this->body_color.setHsb(ofRandom(255), 255, 255);
	//this->body_color = ofColor(0);
}

void Particle::apply_force(ofVec2f force) {
	this->acceleration += force;
}

void Particle::update() {
	this->acceleration += this->velocity;
	this->location += this->acceleration;
	this->acceleration *= 0;

	if (this->location.x < 0) {
		this->location.x = 0;
		this->velocity.x *= -1;
	}
	else if (this->location.x > ofGetWidth()) {
		this->location.x = ofGetWidth();
		this->velocity.x *= -1;
	}

	if (this->location.y < 0) {
		this->location.y = 0;
		this->velocity.y *= -1;
	}
	else if (this->location.y > ofGetHeight()) {
		this->location.y = ofGetHeight();
		this->velocity.y *= -1;
	}
}

void Particle::draw(vector<shared_ptr<Particle>> particles) {

	ofSetColor(this->body_color);
	ofDrawCircle(this->location, 1);

	float distance;
	for (int i = 0; i < particles.size(); i++) {
		distance = this->location.distance(particles[i]->get_location());
		if (distance > 0 && distance < 64) {
			ofDrawLine(this->location, particles[i]->get_location());
		}
	}
}

ofVec2f Particle::get_location() {
	return this->location;
}

#include "Particle.h"

Particle::Particle() {

this->location = ofVec2f(ofRandom(ofGetWidth()), ofRandom(ofGetHeight()));

this->velocity = ofVec2f(ofRandom(-2, 2), ofRandom(-2, 2));

this->acceleration = ofVec2f();

this->body_color.setHsb(ofRandom(255), 255, 255);

//this->body_color = ofColor(0);

}

void Particle::apply_force(ofVec2f force) {

this->acceleration += force;

}

void Particle::update() {

this->acceleration += this->velocity;

this->location += this->acceleration;

this->acceleration *= 0;

if (this->location.x < 0) {

this->location.x = 0;

this->velocity.x *= -1;

}

else if (this->location.x > ofGetWidth()) {

this->location.x = ofGetWidth();

this->velocity.x *= -1;

}

if (this->location.y < 0) {

this->location.y = 0;

this->velocity.y *= -1;

}

else if (this->location.y > ofGetHeight()) {

this->location.y = ofGetHeight();

this->velocity.y *= -1;

}

void Particle::draw(vector<shared_ptr<Particle>> particles) {

ofSetColor(this->body_color);

ofDrawCircle(this->location, 1);

float distance;

for (int i = 0; i < particles.size(); i++) {

distance = this->location.distance(particles[i]->get_location());

if (distance > 0 && distance < 64) {

ofDrawLine(this->location, particles[i]->get_location());

}

ofVec2f Particle::get_location() {

return this->location;

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2017年10月20日2017年12月5日

Insta20171019

[ Video ]

[ About ]
Box2DのオブジェクトをMouse操作で遊んでいます。
マウスの左ボタンでオブジェクトを掴んでいます。
マウスの中ボタンでRectを生成
マウスの右ボタンでCircleを生成

[ Source ]

#pragma once
#include "ofMain.h"
#include "ofxBox2d.h"

class ofApp : public ofBaseApp{
	public:
		void setup();
		void update();
		void draw();
		void mousePressed(int x, int y, int button);
		void mouseReleased(int x, int y, int button);

		void keyPressed(int key) {}
		void keyReleased(int key) {}
		void mouseMoved(int x, int y) {}
		void mouseDragged(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) {}
		
		ofVec2f press_position;

		ofxBox2d box2d;

		vector<shared_ptr<ofxBox2dCircle>> circles;
		vector<ofColor> circles_color;

		vector<shared_ptr<ofxBox2dRect>> rects;
		vector<ofColor> rects_color;
};

#pragma once

#include "ofMain.h"

#include "ofxBox2d.h"

class ofApp : public ofBaseApp{

public:

void setup();

void update();

void draw();

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

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

void keyPressed(int key) {}

void keyReleased(int key) {}

void mouseMoved(int x, int y) {}

void mouseDragged(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) {}

ofVec2f press_position;

ofxBox2d box2d;

vector<shared_ptr<ofxBox2dCircle>> circles;

vector<ofColor> circles_color;

vector<shared_ptr<ofxBox2dRect>> rects;

vector<ofColor> rects_color;

};

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup(){
	ofSetFrameRate(60);
	ofBackground(0);
	ofSetWindowTitle("Insta");

	ofSetCircleResolution(60);
	ofSetLineWidth(1.5);

	this->box2d.init();
	this->box2d.setGravity(0, 10);
	this->box2d.createBounds();
	this->box2d.setFPS(60);
	this->box2d.registerGrabbing();
}

//--------------------------------------------------------------
void ofApp::update(){
	this->box2d.update();
}

//--------------------------------------------------------------
void ofApp::draw(){
	
	if (this->press_position != ofVec2f(0, 0)){
		// Center button
		if (ofGetMousePressed(1)) {
			ofVec2f mouse_position = ofVec2f(ofGetMouseX(), ofGetMouseY());
			ofVec2f difference = mouse_position - this->press_position;

			ofColor line_color;
			line_color.setHsb(ofGetFrameNum() % 255, 255, 255);
			ofSetColor(line_color);

			ofFill();
			ofDrawRectangle(this->press_position, difference.x, difference.y);
		}

		// Right button
		if (ofGetMousePressed(2)) {
			ofVec2f mouse_position = ofVec2f(ofGetMouseX(), ofGetMouseY());
			float r = mouse_position.distance(this->press_position);

			ofColor line_color;
			line_color.setHsb(ofGetFrameNum() % 255, 255, 255);
			ofSetColor(line_color);

			ofNoFill();
			ofDrawEllipse(this->press_position, r * 2, r * 2);
		}
	}

	ofNoFill();

	for (int i = 0; i < this->circles.size(); i++) {
		ofSetColor(this->circles_color[i]);
		this->circles[i].get()->draw();
	}
	for (int i = 0; i < this->rects.size(); i++) {
		ofSetColor(this->rects_color[i]);
		this->rects[i].get()->draw();
	}

	this->box2d.drawGround();
}

//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button) {
	// Center or Right button
	if (button == 1 || button == 2) {
		this->press_position = ofVec2f(x, y);
	}
}


//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button) {

	// Center button
	if (button == 1) {
		ofVec2f mouse_position = ofVec2f(x, y);
		ofVec2f difference = mouse_position - this->press_position;

		this->rects.push_back(shared_ptr<ofxBox2dRect>(new ofxBox2dRect));
		this->rects.back().get()->setPhysics(3.0, 0.53, 0.1);
		this->rects.back().get()->setup(this->box2d.world, this->press_position.x + difference.x / 2, this->press_position.y + difference.y / 2, difference.x, difference.y);

		ofColor rect_color;
		rect_color.setHsb(ofGetFrameNum() % 255, 255, 255);
		this->rects_color.push_back(rect_color);

		this->press_position = ofVec2f(0, 0);
	}

	// Right button
	if (button == 2) {
		ofVec2f mouse_position = ofVec2f(x, y);
		float r = mouse_position.distance(this->press_position);

		this->circles.push_back(shared_ptr<ofxBox2dCircle>(new ofxBox2dCircle));
		this->circles.back().get()->setPhysics(3.0, 0.53, 0.1);
		this->circles.back().get()->setup(this->box2d.getWorld(), this->press_position.x, this->press_position.y, r);

		ofColor circle_color;
		circle_color.setHsb(ofGetFrameNum() % 255, 255, 255);
		this->circles_color.push_back(circle_color);

		this->press_position = ofVec2f(0, 0);
	}
}

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

#include "ofApp.h"

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

void ofApp::setup(){

ofSetFrameRate(60);

ofBackground(0);

ofSetWindowTitle("Insta");

ofSetCircleResolution(60);

ofSetLineWidth(1.5);

this->box2d.init();

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

this->box2d.createBounds();

this->box2d.setFPS(60);

this->box2d.registerGrabbing();

}

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

void ofApp::update(){

this->box2d.update();

}

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

void ofApp::draw(){

if (this->press_position != ofVec2f(0, 0)){

// Center button

if (ofGetMousePressed(1)) {

ofVec2f mouse_position = ofVec2f(ofGetMouseX(), ofGetMouseY());

ofVec2f difference = mouse_position - this->press_position;

ofColor line_color;

line_color.setHsb(ofGetFrameNum() % 255, 255, 255);

ofSetColor(line_color);

ofFill();

ofDrawRectangle(this->press_position, difference.x, difference.y);

}

// Right button

if (ofGetMousePressed(2)) {

ofVec2f mouse_position = ofVec2f(ofGetMouseX(), ofGetMouseY());

float r = mouse_position.distance(this->press_position);

ofColor line_color;

line_color.setHsb(ofGetFrameNum() % 255, 255, 255);

ofSetColor(line_color);

ofNoFill();

ofDrawEllipse(this->press_position, r * 2, r * 2);

}

ofNoFill();

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

ofSetColor(this->circles_color[i]);

this->circles[i].get()->draw();

}

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

ofSetColor(this->rects_color[i]);

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

}

this->box2d.drawGround();

}

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

void ofApp::mousePressed(int x, int y, int button) {

// Center or Right button

if (button == 1 || button == 2) {

this->press_position = ofVec2f(x, y);

}

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

void ofApp::mouseReleased(int x, int y, int button) {

// Center button

if (button == 1) {

ofVec2f mouse_position = ofVec2f(x, y);

ofVec2f difference = mouse_position - this->press_position;

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

this->rects.back().get()->setPhysics(3.0, 0.53, 0.1);

this->rects.back().get()->setup(this->box2d.world, this->press_position.x + difference.x / 2, this->press_position.y + difference.y / 2, difference.x, difference.y);

ofColor rect_color;

rect_color.setHsb(ofGetFrameNum() % 255, 255, 255);

this->rects_color.push_back(rect_color);

this->press_position = ofVec2f(0, 0);

}

// Right button

if (button == 2) {

ofVec2f mouse_position = ofVec2f(x, y);

float r = mouse_position.distance(this->press_position);

this->circles.push_back(shared_ptr<ofxBox2dCircle>(new ofxBox2dCircle));

this->circles.back().get()->setPhysics(3.0, 0.53, 0.1);

this->circles.back().get()->setup(this->box2d.getWorld(), this->press_position.x, this->press_position.y, r);

ofColor circle_color;

circle_color.setHsb(ofGetFrameNum() % 255, 255, 255);

this->circles_color.push_back(circle_color);

this->press_position = ofVec2f(0, 0);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
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