openFrameworks – ページ 413 – プログラミング de 落描き

2022年2月17日

Vivid yellow. Draw by openFrameworks

[ Video ]

[ About ]
配色デザインインスピレーションブックⅢという本を購入して参照しました。

Vivid yellow.

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

	glm::vec3 make_point(float R, float r, float u, float v);

	ofEasyCam cam;
	ofMesh face_mesh, frame_mesh;

	vector<ofColor> color_palette;
	int base_color_index;
};

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

glm::vec3 make_point(float R, float r, float u, float v);

ofEasyCam cam;

ofMesh face_mesh, frame_mesh;

vector<ofColor> color_palette;

int base_color_index;

};

#include "ofApp.h"

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

	ofSetFrameRate(60);
	ofSetWindowTitle("openframeworks");

	// 配色デザイン P092 ビビットイエロー
	this->color_palette.push_back(ofColor(255, 240, 0));
	this->color_palette.push_back(ofColor(245, 217, 51));
	this->color_palette.push_back(ofColor(232, 229, 0));
	this->color_palette.push_back(ofColor(250, 229, 51));
	this->color_palette.push_back(ofColor(231, 180, 33));
	this->color_palette.push_back(ofColor(255, 255, 255));
	this->color_palette.push_back(ofColor(215, 131, 76));
	this->color_palette.push_back(ofColor(138, 196, 221));


	ofSetLineWidth(2);
	ofEnableDepthTest();

	this->frame_mesh.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);
}

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

	ofSeedRandom(39);

	if (ofGetFrameNum() % 66 == 0) {

		vector<ofColor> tmp_color_palette;
		for (int i = 1; i < this->color_palette.size(); i++) {

			tmp_color_palette.push_back(this->color_palette[i]);
		}
		tmp_color_palette.push_back(this->color_palette[0]);
		this->color_palette = tmp_color_palette;

		ofBackground(this->color_palette[this->color_palette.size() - 1]);
	}

	this->face_mesh.clear();
	this->frame_mesh.clear();

	auto R = 100.f;
	auto u = 0.f;
	auto u_step = 10.f;
	auto v_step = 5.f;

	ofColor color_1, color_2;
	for (int i = 0; i < 36; i++) {

		auto r = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 10, 30);

		float angle_z = (i * 5) * DEG_TO_RAD;
		auto rotation_z = glm::rotate(glm::mat4(), angle_z, glm::vec3(0, 0, 1));

		for (auto v = 0; v < 360; v += v_step) {

			vector<glm::vec3> vertices{
				glm::vec4(this->make_point(R, r, u, v), 0) * rotation_z,
				glm::vec4(this->make_point(R, r, u + u_step, v + v_step), 0) * rotation_z,
				glm::vec4(this->make_point(R, r, u, v + v_step), 0) * rotation_z,
				glm::vec4(this->make_point(R, r, u - u_step, v), 0) * rotation_z
			};

			this->face_mesh.addVertices(vertices);
			this->frame_mesh.addVertices(vertices);

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

				this->face_mesh.addColor(this->color_palette[i % (this->color_palette.size() - 1)]);
				this->frame_mesh.addColor(this->color_palette[(i + 3) % (this->color_palette.size() - 1)]);
			}

			auto index = this->face_mesh.getVertices().size() - 1;

			this->face_mesh.addIndex(index - 3); this->face_mesh.addIndex(index - 2); this->face_mesh.addIndex(index - 1);
			this->face_mesh.addIndex(index); this->face_mesh.addIndex(index - 3); this->face_mesh.addIndex(index - 1);

			this->frame_mesh.addIndex(index - 3); this->frame_mesh.addIndex(index - 2);
			this->frame_mesh.addIndex(index); this->frame_mesh.addIndex(index - 1);

			u += u_step;
		}
	}
}

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

	this->cam.begin();

	this->face_mesh.draw();
	this->frame_mesh.draw();

	this->cam.end();
}

//--------------------------------------------------------------
glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

	// 数学デッサン教室 描いて楽しむ数学たち　P.31

	u *= DEG_TO_RAD;
	v *= DEG_TO_RAD;

	auto x = (R + r * cos(u)) * cos(v);
	auto y = (R + r * cos(u)) * sin(v);
	auto z = r * sin(u);

	return glm::vec3(x, y, z);
}


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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

// 配色デザイン P092 ビビットイエロー

this->color_palette.push_back(ofColor(255, 240, 0));

this->color_palette.push_back(ofColor(245, 217, 51));

this->color_palette.push_back(ofColor(232, 229, 0));

this->color_palette.push_back(ofColor(250, 229, 51));

this->color_palette.push_back(ofColor(231, 180, 33));

this->color_palette.push_back(ofColor(255, 255, 255));

this->color_palette.push_back(ofColor(215, 131, 76));

this->color_palette.push_back(ofColor(138, 196, 221));

ofSetLineWidth(2);

ofEnableDepthTest();

this->frame_mesh.setMode(ofPrimitiveMode::OF_PRIMITIVE_LINES);

}

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

void ofApp::update() {

ofSeedRandom(39);

if (ofGetFrameNum() % 66 == 0) {

vector<ofColor> tmp_color_palette;

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

tmp_color_palette.push_back(this->color_palette[i]);

}

tmp_color_palette.push_back(this->color_palette[0]);

this->color_palette = tmp_color_palette;

ofBackground(this->color_palette[this->color_palette.size() - 1]);

}

this->face_mesh.clear();

this->frame_mesh.clear();

auto R = 100.f;

auto u = 0.f;

auto u_step = 10.f;

auto v_step = 5.f;

ofColor color_1, color_2;

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

auto r = ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.005), 0, 1, 10, 30);

float angle_z = (i * 5) * DEG_TO_RAD;

auto rotation_z = glm::rotate(glm::mat4(), angle_z, glm::vec3(0, 0, 1));

for (auto v = 0; v < 360; v += v_step) {

vector<glm::vec3> vertices{

glm::vec4(this->make_point(R, r, u, v), 0) * rotation_z,

glm::vec4(this->make_point(R, r, u + u_step, v + v_step), 0) * rotation_z,

glm::vec4(this->make_point(R, r, u, v + v_step), 0) * rotation_z,

glm::vec4(this->make_point(R, r, u - u_step, v), 0) * rotation_z

};

this->face_mesh.addVertices(vertices);

this->frame_mesh.addVertices(vertices);

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

this->face_mesh.addColor(this->color_palette[i % (this->color_palette.size() - 1)]);

this->frame_mesh.addColor(this->color_palette[(i + 3) % (this->color_palette.size() - 1)]);

}

auto index = this->face_mesh.getVertices().size() - 1;

this->face_mesh.addIndex(index - 3); this->face_mesh.addIndex(index - 2); this->face_mesh.addIndex(index - 1);

this->face_mesh.addIndex(index); this->face_mesh.addIndex(index - 3); this->face_mesh.addIndex(index - 1);

this->frame_mesh.addIndex(index - 3); this->frame_mesh.addIndex(index - 2);

this->frame_mesh.addIndex(index); this->frame_mesh.addIndex(index - 1);

u += u_step;

}

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

void ofApp::draw() {

this->cam.begin();

this->face_mesh.draw();

this->frame_mesh.draw();

this->cam.end();

}

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

glm::vec3 ofApp::make_point(float R, float r, float u, float v) {

// 数学デッサン教室描いて楽しむ数学たち　P.31

u *= DEG_TO_RAD;

v *= DEG_TO_RAD;

auto x = (R + r * cos(u)) * cos(v);

auto y = (R + r * cos(u)) * sin(v);

auto z = r * sin(u);

return glm::vec3(x, y, z);

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2022年2月16日

Soft Pink. Draw by openFrameworks

[ Video ]

[ Souce ]
配色デザインインスピレーションブックⅢという本を購入して参照しました。

Soft Pink.

[ 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(60);
	ofSetWindowTitle("openframeworks");

	ofBackground(255);
	ofSetCircleResolution(60);
}

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

	ofSeedRandom(39);
}

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

	// 配色デザイン P192 ソフトピンク
	vector<ofColor> colors;
	colors.push_back(ofColor(221, 155, 165));
	colors.push_back(ofColor(224, 186, 212));
	colors.push_back(ofColor(229, 181, 161));
	colors.push_back(ofColor(208, 130, 139));
	colors.push_back(ofColor(202, 72, 90));
	colors.push_back(ofColor(163, 150, 197));
	colors.push_back(ofColor(184, 145, 26));
	colors.push_back(ofColor(250, 241, 239));

	int span = 144;
	for (int x = span; x <= 720 - span; x += span) {

		for (int y = span; y <= 720 - span; y += span) {

			ofPushMatrix();
			ofTranslate(x, y);

			int color_1_index = ofRandom(colors.size());
			int color_2_index = (color_1_index + (int)ofRandom(1, colors.size() - 1)) % colors.size();
			int color_3_index = (color_2_index + (int)ofRandom(1, colors.size() - 1)) % colors.size();

			ofFill();
			ofSetColor(colors[color_1_index]);
			ofDrawCircle(glm::vec3(), 58);

			ofNoFill();
			ofSetColor(colors[color_2_index]);
			ofDrawCircle(glm::vec3(), 58);

			for (auto head_size = 4; head_size <= 9; head_size += 5) {

				if (head_size == 4) {

					ofSetColor(colors[color_2_index]);
				}
				else {

					ofSetColor(colors[color_3_index]);
				}

				ofMesh mesh;
				vector<glm::vec3> right, left, frame;
				auto noise_seed_deg = ofRandom(1000);
				auto noise_seed_radius = ofRandom(1000);

				glm::vec3 last_location;
				float last_theta, last_radius;

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

					auto noise_deg = ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i) * 0.005), 0, 1, -360, 360);
					auto noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i) * 0.01), 0, 1, -50, 50);
					auto next_noise_deg = ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -360, 360);
					auto next_noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i + 1) * 0.01), 0, 1, -50, 50);

					auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);
					auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 0);

					auto direction = next - location;
					auto theta = atan2(direction.y, direction.x);

					right.push_back(location + glm::vec3(ofMap(i, 0, 25, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, 25, 0, head_size) * sin(theta + PI * 0.5), 0));
					left.push_back(location + glm::vec3(ofMap(i, 0, 25, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, 25, 0, head_size) * sin(theta - PI * 0.5), 0));

					last_location = location;
					last_theta = theta;
					last_radius = noise_radius;
				}

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

					mesh.addVertex(left[i]);
					mesh.addVertex(right[i]);
				}

				for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

					mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);
					mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);
				}

				auto tmp_head_size = ofMap(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 0, head_size);

				mesh.addVertex(last_location);
				int index = mesh.getNumVertices();
				for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

					mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));
					frame.push_back(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));
				}

				for (int i = index; i < mesh.getNumVertices() - 1; i++) {

					mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);
				}

				int span = ofRandom(3, 6);
				int deg_span = 360 / span;
				for (int deg = 0; deg < 360; deg += 30) {

					ofRotate(deg_span);
					mesh.draw();
				}
			}

			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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(60);

ofSetWindowTitle("openframeworks");

ofBackground(255);

ofSetCircleResolution(60);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

// 配色デザイン P192 ソフトピンク

vector<ofColor> colors;

colors.push_back(ofColor(221, 155, 165));

colors.push_back(ofColor(224, 186, 212));

colors.push_back(ofColor(229, 181, 161));

colors.push_back(ofColor(208, 130, 139));

colors.push_back(ofColor(202, 72, 90));

colors.push_back(ofColor(163, 150, 197));

colors.push_back(ofColor(184, 145, 26));

colors.push_back(ofColor(250, 241, 239));

int span = 144;

for (int x = span; x <= 720 - span; x += span) {

for (int y = span; y <= 720 - span; y += span) {

ofPushMatrix();

ofTranslate(x, y);

int color_1_index = ofRandom(colors.size());

int color_2_index = (color_1_index + (int)ofRandom(1, colors.size() - 1)) % colors.size();

int color_3_index = (color_2_index + (int)ofRandom(1, colors.size() - 1)) % colors.size();

ofFill();

ofSetColor(colors[color_1_index]);

ofDrawCircle(glm::vec3(), 58);

ofNoFill();

ofSetColor(colors[color_2_index]);

ofDrawCircle(glm::vec3(), 58);

for (auto head_size = 4; head_size <= 9; head_size += 5) {

if (head_size == 4) {

ofSetColor(colors[color_2_index]);

}

else {

ofSetColor(colors[color_3_index]);

}

ofMesh mesh;

vector<glm::vec3> right, left, frame;

auto noise_seed_deg = ofRandom(1000);

auto noise_seed_radius = ofRandom(1000);

glm::vec3 last_location;

float last_theta, last_radius;

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

auto noise_deg = ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i) * 0.005), 0, 1, -360, 360);

auto noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i) * 0.01), 0, 1, -50, 50);

auto next_noise_deg = ofMap(ofNoise(noise_seed_deg, (ofGetFrameNum() + i + 1) * 0.005), 0, 1, -360, 360);

auto next_noise_radius = ofMap(ofNoise(noise_seed_radius, (ofGetFrameNum() + i + 1) * 0.01), 0, 1, -50, 50);

auto location = glm::vec3(noise_radius * cos(noise_deg * DEG_TO_RAD), noise_radius * sin(noise_deg * DEG_TO_RAD), 0);

auto next = glm::vec3(next_noise_radius * cos(next_noise_deg * DEG_TO_RAD), next_noise_radius * sin(next_noise_deg * DEG_TO_RAD), 0);

auto direction = next - location;

auto theta = atan2(direction.y, direction.x);

right.push_back(location + glm::vec3(ofMap(i, 0, 25, 0, head_size) * cos(theta + PI * 0.5), ofMap(i, 0, 25, 0, head_size) * sin(theta + PI * 0.5), 0));

left.push_back(location + glm::vec3(ofMap(i, 0, 25, 0, head_size) * cos(theta - PI * 0.5), ofMap(i, 0, 25, 0, head_size) * sin(theta - PI * 0.5), 0));

last_location = location;

last_theta = theta;

last_radius = noise_radius;

}

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

mesh.addVertex(left[i]);

mesh.addVertex(right[i]);

}

for (int i = 0; i < mesh.getNumVertices() - 2; i += 2) {

mesh.addIndex(i + 0); mesh.addIndex(i + 1); mesh.addIndex(i + 3);

mesh.addIndex(i + 0); mesh.addIndex(i + 2); mesh.addIndex(i + 3);

}

auto tmp_head_size = ofMap(mesh.getNumVertices() - 2, 0, mesh.getNumVertices(), 0, head_size);

mesh.addVertex(last_location);

int index = mesh.getNumVertices();

for (auto theta = last_theta - PI * 0.5; theta <= last_theta + PI * 0.5; theta += PI / 20) {

mesh.addVertex(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));

frame.push_back(last_location + glm::vec3(tmp_head_size * cos(theta), tmp_head_size * sin(theta), 0));

}

for (int i = index; i < mesh.getNumVertices() - 1; i++) {

mesh.addIndex(index); mesh.addIndex(i + 0); mesh.addIndex(i + 1);

}

int span = ofRandom(3, 6);

int deg_span = 360 / span;

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

ofRotate(deg_span);

mesh.draw();

}

ofPopMatrix();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

2022年2月15日2022年2月15日

Connect points with curve. Draw by openFrameworks

[ Video ]

[ About ]
ベジェ曲線でランダムな点を結ぶ。

Connect random points with Bezier curves.

[ 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(255);
	ofSetColor(0);
	ofSetLineWidth(2);
}

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

	ofSeedRandom(39);
}

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

	vector<glm::vec2> location_list;
	vector<float> deg_list;
	vector<bool> flag_list;
	vector<int> near_index_list;

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

		location_list.push_back(glm::vec2(ofRandom(50, ofGetWidth() - 50), ofRandom(50, ofGetHeight() - 50)));
		deg_list.push_back(ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.008), 0, 1, -360, 360));
		flag_list.push_back(false);
	}

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

		ofNoFill();
		for (int k = i + 1; k < location_list.size(); k++) {

			auto distance = glm::distance(location_list[i], location_list[k]);
			if (distance < 80) {

				auto handle_1 = location_list[i] + glm::vec2(50 * cos(deg_list[i] * DEG_TO_RAD), 50 * sin(deg_list[i] * DEG_TO_RAD));
				auto handle_2 = location_list[k] + glm::vec2(50 * cos(deg_list[k] * DEG_TO_RAD), 50 * sin(deg_list[k] * DEG_TO_RAD));

				ofBeginShape();
				ofVertex(location_list[i]);
				ofBezierVertex(handle_1, handle_2, location_list[k]);
				ofEndShape();

				flag_list[i] = true;
				flag_list[k] = true;
			}
		}

		ofFill();
		ofDrawCircle(location_list[i], 5);
	}

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

		if (flag_list[i] == false) {

			float min_distance = ofGetWidth() + ofGetHeight();
			int min_index = 0;
			for (int k = 0; k < location_list.size(); k++) {

				if (i == k) { continue; }
				auto distance = glm::distance(location_list[i], location_list[k]);
				if (distance < min_distance) {

					min_distance = distance;
					min_index = k;
				}
			}

			auto handle_1 = location_list[i] + glm::vec2(50 * cos(deg_list[i] * DEG_TO_RAD), 50 * sin(deg_list[i] * DEG_TO_RAD));
			auto handle_2 = location_list[min_index] + glm::vec2(50 * cos(deg_list[min_index] * DEG_TO_RAD), 50 * sin(deg_list[min_index] * DEG_TO_RAD));

			ofBeginShape();
			ofVertex(location_list[i]);
			ofBezierVertex(handle_1, handle_2, location_list[min_index]);
			ofEndShape();
		}
	}
}

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

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

#include "ofApp.h"

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

void ofApp::setup() {

ofSetFrameRate(30);

ofSetWindowTitle("openFrameworks");

ofBackground(255);

ofSetColor(0);

ofSetLineWidth(2);

}

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

void ofApp::update() {

ofSeedRandom(39);

}

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

void ofApp::draw() {

vector<glm::vec2> location_list;

vector<float> deg_list;

vector<bool> flag_list;

vector<int> near_index_list;

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

location_list.push_back(glm::vec2(ofRandom(50, ofGetWidth() - 50), ofRandom(50, ofGetHeight() - 50)));

deg_list.push_back(ofMap(ofNoise(ofRandom(1000), ofGetFrameNum() * 0.008), 0, 1, -360, 360));

flag_list.push_back(false);

}

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

ofNoFill();

for (int k = i + 1; k < location_list.size(); k++) {

auto distance = glm::distance(location_list[i], location_list[k]);

if (distance < 80) {

auto handle_1 = location_list[i] + glm::vec2(50 * cos(deg_list[i] * DEG_TO_RAD), 50 * sin(deg_list[i] * DEG_TO_RAD));

auto handle_2 = location_list[k] + glm::vec2(50 * cos(deg_list[k] * DEG_TO_RAD), 50 * sin(deg_list[k] * DEG_TO_RAD));

ofBeginShape();

ofVertex(location_list[i]);

ofBezierVertex(handle_1, handle_2, location_list[k]);

ofEndShape();

flag_list[i] = true;

flag_list[k] = true;

}

ofFill();

ofDrawCircle(location_list[i], 5);

}

ofNoFill();

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

if (flag_list[i] == false) {

float min_distance = ofGetWidth() + ofGetHeight();

int min_index = 0;

for (int k = 0; k < location_list.size(); k++) {

if (i == k) { continue; }

auto distance = glm::distance(location_list[i], location_list[k]);

if (distance < min_distance) {

min_distance = distance;

min_index = k;

}

auto handle_1 = location_list[i] + glm::vec2(50 * cos(deg_list[i] * DEG_TO_RAD), 50 * sin(deg_list[i] * DEG_TO_RAD));

auto handle_2 = location_list[min_index] + glm::vec2(50 * cos(deg_list[min_index] * DEG_TO_RAD), 50 * sin(deg_list[min_index] * DEG_TO_RAD));

ofBeginShape();

ofVertex(location_list[i]);

ofBezierVertex(handle_1, handle_2, location_list[min_index]);

ofEndShape();

}

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

int main() {

ofSetupOpenGL(720, 720, OF_WINDOW);

ofRunApp(new ofApp());

}

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

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