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

2017年11月18日2017年12月5日

Insta20171117

[ Video ]

[ About ]
R/G/B/Frame NumberをNoise関数の引数にして、画素の高さを決めています。

The pixel height is determined by using R/G/B/Frame Number as an argument of Noise function.

[ Source ]

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

	ofImage lenna;
	ofEasyCam cam;

};

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

ofImage lenna;

ofEasyCam cam;

};

#include "ofApp.h"

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

	ofSetDepthTest(true);

	this->lenna.loadImage("Lenna.png");
}

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

//--------------------------------------------------------------
void ofApp::draw() {
	
	this->cam.begin();
	ofRotateZ(180);

	ofPixels pixels = this->lenna.getPixelsRef();
	ofColor pixel_color;
	float noise_value;
	float height;
	int size = 3;

	for (int x = 0; x < pixels.getWidth(); x += size) {
		for (int y = 0; y < pixels.getHeight(); y += size) {
			pixel_color = pixels.getColor(x, y);
			ofSetColor(pixel_color);

			noise_value = ofNoise(pixel_color.r * 0.005, pixel_color.g * 0.005, pixel_color.b * 0.005, ofGetFrameNum() * 0.05);
			height = 300 * noise_value;

			ofDrawBox(ofVec3f(x - ofGetWidth() / 2, y - ofGetHeight() / 2, height / 2), size, size, height);
		}
	}

	this->cam.end();
}

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofBackground(255);

ofSetWindowTitle("Insta");

ofSetDepthTest(true);

this->lenna.loadImage("Lenna.png");

}

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

void ofApp::update(){ }

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

void ofApp::draw() {

this->cam.begin();

ofRotateZ(180);

ofPixels pixels = this->lenna.getPixelsRef();

ofColor pixel_color;

float noise_value;

float height;

int size = 3;

for (int x = 0; x < pixels.getWidth(); x += size) {

for (int y = 0; y < pixels.getHeight(); y += size) {

pixel_color = pixels.getColor(x, y);

ofSetColor(pixel_color);

noise_value = ofNoise(pixel_color.r * 0.005, pixel_color.g * 0.005, pixel_color.b * 0.005, ofGetFrameNum() * 0.05);

height = 300 * noise_value;

ofDrawBox(ofVec3f(x - ofGetWidth() / 2, y - ofGetHeight() / 2, height / 2), size, size, height);

}

this->cam.end();

}

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

int main() {

ofSetupOpenGL(512, 512, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

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月16日2017年11月15日

Insta20171115

[ Video ]

[ About ]
OpenCV3.3.1に組み込まれたDarknet Yolo v2を使ってみました。
画像からクラス識別をしています。

I tried using Darknet Yolo v2 embedded in OpenCV 3.3.1.
It is classified from the image.

[ Source ]

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

#include <fstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

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

int main(int argc, char** argv)
{
	String modelConfiguration = "yolo.cfg";
	String modelBinary = "yolo.weights";
    dnn::Net net = readNetFromDarknet(modelConfiguration, modelBinary);
    if (net.empty()) {
		return -1;
    }

	cv::Mat frame, resized, inputBlob, detectionMat;
	cv::VideoCapture cap("video.mp4");
	if (!cap.isOpened()) {
		return -1;
	}

	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" };

	while (true) {

		cap >> frame;

		if (frame.empty()) {
			return 1;
		}

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

		float confidenceThreshold = 0.25;
		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 - 30,
					(int)(xRightTop - xLeftBottom),
					30);
								
				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_DUPLEX, 1.5, cv::Scalar(0), 3);
				cv::rectangle(frame, object, Scalar(0, 255, 0), 2);
			}
		}

		imshow("detections", frame);
		waitKey(1);
	}

    return 0;
} // main

100

101

102

103

104

105

106

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

#include <fstream>

#include <iostream>

#include <algorithm>

#include <cstdlib>

using namespace std;

const size_t network_width = 416;

const size_t network_height = 416;

int main(int argc, char** argv)

{

String modelConfiguration = "yolo.cfg";

String modelBinary = "yolo.weights";

dnn::Net net = readNetFromDarknet(modelConfiguration, modelBinary);

if (net.empty()) {

return -1;

}

cv::Mat frame, resized, inputBlob, detectionMat;

cv::VideoCapture cap("video.mp4");

if (!cap.isOpened()) {

return -1;

}

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