Programming – プログラミング de 落描き

2023年8月28日

Swarm of circles. Draw by 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) {};
};

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

};

#include "ofApp.h"	

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

	ofSetFrameRate(30);
	ofSetWindowTitle("openFrameworks");

	ofBackground(39);
	ofSetLineWidth(2);
}

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

	ofSeedRandom(39);
}

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

	ofTranslate(ofGetWindowSize() * 0.5);

	ofColor color, line_color;
	for (int i = 0; i < 1200; i++) {

		auto x = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0025), 0, 1, -320, 320);
		auto y = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0025), 0, 1, -320, 320);
		auto size = ofRandom(5, 20);
		
		auto hue = ofRandom(180, 230);
		color.setHsb(hue, 255,  ofMap(i, 0, 1200, 0, 255));
		line_color.setHsb(hue, ofMap(i, 0, 1200, 255, 0), 255);

		ofFill();
		ofSetColor(color);
		ofDrawCircle(glm::vec2(x, y), size);

		ofNoFill();
		ofSetColor(line_color);
		ofDrawCircle(glm::vec2(x, y), size);
	}
}


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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openFrameworks");

ofBackground(39);

ofSetLineWidth(2);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

ofTranslate(ofGetWindowSize() * 0.5);

ofColor color, line_color;

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

auto x = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0025), 0, 1, -320, 320);

auto y = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.0025), 0, 1, -320, 320);

auto size = ofRandom(5, 20);

auto hue = ofRandom(180, 230);

color.setHsb(hue, 255, ofMap(i, 0, 1200, 0, 255));

line_color.setHsb(hue, ofMap(i, 0, 1200, 255, 0), 255);

ofFill();

ofSetColor(color);

ofDrawCircle(glm::vec2(x, y), size);

ofNoFill();

ofSetColor(line_color);

ofDrawCircle(glm::vec2(x, y), size);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

[ほしいものリスト]
Amazon

[ Sponsor Link ]

2017年11月20日2017年11月21日

Insta20171119

[ Video ]

[ About ]
カメラの画像をリアルタイムに識別しています。

Surface front camera images are classified in real time.

[ 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(0);
	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;
		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 - 15,
					(int)(xRightTop - xLeftBottom),
					15);

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

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

	return 0;
} // main

100

101

#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(0);

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;

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 - 15,

(int)(xRightTop - xLeftBottom),

15);

std::string object_name = "";

if (objectClass < class_names.size()) {

object_name = class_names[objectClass];

}

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

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

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

}

imshow("detections", frame);

waitKey(1);

}

return 0;

} // main

[ Link ]

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