kopia lustrzana https://github.com/evil-mad/stipplegen
1231 wiersze
34 KiB
Plaintext
1231 wiersze
34 KiB
Plaintext
/**
|
|
|
|
StippleGen_2_40
|
|
|
|
SVG Stipple Generator, v. 2.40
|
|
Copyright (C) 2016 by Windell H. Oskay, www.evilmadscientist.com
|
|
|
|
Full Documentation: http://wiki.evilmadscientist.com/StippleGen
|
|
Blog post about the release: http://www.evilmadscientist.com/go/stipple2
|
|
|
|
An implementation of Weighted Voronoi Stippling:
|
|
http://mrl.nyu.edu/~ajsecord/stipples.html
|
|
|
|
*******************************************************************************
|
|
|
|
Change Log:
|
|
|
|
v 2.4
|
|
* Compiling in Processing 3.0.1
|
|
* Add GUI option to fill circles with a spiral
|
|
|
|
v 2.3
|
|
* Forked from 2.1.1
|
|
* Fixed saving bug
|
|
|
|
v 2.20
|
|
* [Cancelled development branch.]
|
|
|
|
v 2.1.1
|
|
* Faster now, with number of stipples calculated at a time.
|
|
|
|
v 2.1.0
|
|
* Now compiling in Processing 2.0b6
|
|
* selectInput() and selectOutput() calls modified for Processing 2.
|
|
|
|
v 2.02
|
|
* Force files to end in .svg
|
|
* Fix bug that gave wrong size to stipple files saved white stipples on black background
|
|
|
|
v 2.01:
|
|
* Improved handling of Save process, to prevent accidental "not saving" by users.
|
|
|
|
v 2.0:
|
|
* Add tone reversal option (white on black / black on white)
|
|
* Reduce vertical extent of GUI, to reduce likelihood of cropping on small screens
|
|
* Speling corections
|
|
* Fixed a bug that caused unintended cropping of long, wide images
|
|
* Reorganized GUI controls
|
|
* Fail less disgracefully when a bad image type is selected.
|
|
|
|
*******************************************************************************
|
|
|
|
Program is based on the Toxic Libs Library ( http://toxiclibs.org/ )
|
|
& example code:
|
|
http://forum.processing.org/topic/toxiclib-voronoi-example-sketch
|
|
|
|
Additional inspiration:
|
|
Stipple Cam from Jim Bumgardner
|
|
http://joyofprocessing.com/blog/2011/11/stipple-cam/
|
|
|
|
and
|
|
|
|
MeshLibDemo.pde - Demo of Lee Byron's Mesh library, by
|
|
Marius Watz - http://workshop.evolutionzone.com/
|
|
|
|
Requires ControlP5 library and Toxic Libs library:
|
|
http://www.sojamo.de/libraries/controlP5/
|
|
http://bitbucket.org/postspectacular/toxiclibs/downloads/
|
|
|
|
*/
|
|
|
|
/*
|
|
* This is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* http://creativecommons.org/licenses/LGPL/2.1/
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
// You need the controlP5 library from http://www.sojamo.de/libraries/controlP5/
|
|
import controlP5.*;
|
|
|
|
//You need the Toxic Libs library: http://hg.postspectacular.com/toxiclibs/downloads
|
|
import toxi.geom.*;
|
|
import toxi.geom.mesh2d.*;
|
|
import toxi.util.datatypes.*;
|
|
import toxi.processing.*;
|
|
|
|
import javax.swing.UIManager;
|
|
import javax.swing.JFileChooser;
|
|
|
|
// helper class for rendering
|
|
ToxiclibsSupport gfx;
|
|
|
|
// Feel free to play with these three default settings
|
|
float cutoff = 0;
|
|
float minDotSize = 1.75;
|
|
float dotSizeFactor = 4;
|
|
// Max value is normally 10000. Press 'x' key to allow 50000 stipples. (SLOW)
|
|
int maxParticles = 2000;
|
|
|
|
//Scale each cell to fit in a cellBuffer-sized square window for computing the centroid.
|
|
int cellBuffer = 100;
|
|
|
|
// Display window and GUI area sizes:
|
|
int mainwidth;
|
|
int mainheight;
|
|
int borderWidth;
|
|
int ctrlheight;
|
|
int textColumnStart;
|
|
|
|
float lowBorderX;
|
|
float hiBorderX;
|
|
float lowBorderY;
|
|
float hiBorderY;
|
|
|
|
float maxDotSize;
|
|
boolean reInitiallizeArray;
|
|
boolean pausemode;
|
|
boolean fileLoaded;
|
|
boolean saveNow;
|
|
String savePath;
|
|
String[] fileOutput;
|
|
|
|
boolean fillingCircles;
|
|
|
|
String statusDisplay = "Initializing, please wait. :)";
|
|
float millisLastFrame = 0;
|
|
float frameTime = 0;
|
|
|
|
float errorTime;
|
|
String errorDisplay = "";
|
|
boolean errorDisp = false;
|
|
|
|
int generation;
|
|
int particleRouteLength;
|
|
int routeStep;
|
|
|
|
boolean invertImg;
|
|
boolean fileModeTSP;
|
|
boolean tempShowCells;
|
|
boolean showBG, showPath, showCells;
|
|
|
|
int vorPointsAdded;
|
|
boolean voronoiCalculated;
|
|
|
|
int cellsTotal, cellsCalculated, cellsCalculatedLast;
|
|
|
|
int[] particleRoute;
|
|
Vec2D[] particles;
|
|
|
|
ControlP5 cp5;
|
|
Voronoi voronoi;
|
|
Polygon2D regionList[];
|
|
PolygonClipper2D clip;
|
|
PImage img, imgload, imgblur;
|
|
|
|
void LoadImageAndScale() {
|
|
int tempx = 0;
|
|
int tempy = 0;
|
|
|
|
img = createImage(mainwidth, mainheight, RGB);
|
|
imgblur = createImage(mainwidth, mainheight, RGB);
|
|
|
|
img.loadPixels();
|
|
|
|
for (int i = 0; i < img.pixels.length; i++) {
|
|
img.pixels[i] = color(invertImg ? 0 : 255);
|
|
}
|
|
|
|
img.updatePixels();
|
|
|
|
if (!fileLoaded) {
|
|
// Load a demo image, at least until we have a "real" image to work with.
|
|
// Image from: http://commons.wikimedia.org/wiki/File:Kelly,_Grace_(Rear_Window).jpg
|
|
imgload = loadImage("grace.jpg"); // Load demo image
|
|
}
|
|
|
|
if ((imgload.width > mainwidth) || (imgload.height > mainheight)) {
|
|
if (((float)imgload.width / (float)imgload.height) > ((float)mainwidth / (float)mainheight))
|
|
{
|
|
imgload.resize(mainwidth, 0);
|
|
} else {
|
|
imgload.resize(0, mainheight);
|
|
}
|
|
}
|
|
|
|
if (imgload.height < (mainheight - 2)) {
|
|
tempy = (int)((mainheight - imgload.height) / 2) ;
|
|
}
|
|
if (imgload.width < (mainwidth - 2)) {
|
|
tempx = (int)((mainwidth - imgload.width) / 2) ;
|
|
}
|
|
|
|
img.copy(imgload, 0, 0, imgload.width, imgload.height, tempx, tempy, imgload.width, imgload.height);
|
|
// For background image!
|
|
|
|
/*
|
|
// Optional gamma correction for background image.
|
|
img.loadPixels();
|
|
|
|
float tempFloat;
|
|
float GammaValue = 1.0; // Normally in the range 0.25 - 4.0
|
|
|
|
for (int i = 0; i < img.pixels.length; i++) {
|
|
tempFloat = brightness(img.pixels[i])/255;
|
|
img.pixels[i] = color(floor(255 * pow(tempFloat,GammaValue)));
|
|
}
|
|
img.updatePixels();
|
|
*/
|
|
|
|
imgblur.copy(img, 0, 0, img.width, img.height, 0, 0, img.width, img.height);
|
|
// This is a duplicate of the background image, that we will apply a blur to,
|
|
// to reduce "high frequency" noise artifacts.
|
|
|
|
// Low-level blur filter to elminate pixel-to-pixel noise artifacts.
|
|
imgblur.filter(BLUR, 1);
|
|
imgblur.loadPixels();
|
|
}
|
|
|
|
void MainArraySetup() {
|
|
// Main particle array initialization (to be called whenever necessary):
|
|
LoadImageAndScale();
|
|
|
|
// image(img, 0, 0); // SHOW BG IMG
|
|
|
|
particles = new Vec2D[maxParticles];
|
|
|
|
// Fill array by "rejection sampling"
|
|
int i = 0;
|
|
while (i < maxParticles) {
|
|
float fx = lowBorderX + random(hiBorderX - lowBorderX);
|
|
float fy = lowBorderY + random(hiBorderY - lowBorderY);
|
|
|
|
float p = brightness(imgblur.pixels[ floor(fy)*imgblur.width + floor(fx) ])/255;
|
|
// OK to use simple floor_ rounding here, because this is a one-time operation,
|
|
// creating the initial distribution that will be iterated.
|
|
|
|
if (invertImg) {
|
|
p = 1 - p;
|
|
}
|
|
|
|
if (random(1) >= p ) {
|
|
Vec2D p1 = new Vec2D(fx, fy);
|
|
particles[i] = p1;
|
|
i++;
|
|
}
|
|
}
|
|
|
|
particleRouteLength = 0;
|
|
generation = 0;
|
|
millisLastFrame = millis();
|
|
routeStep = 0;
|
|
voronoiCalculated = false;
|
|
cellsCalculated = 0;
|
|
vorPointsAdded = 0;
|
|
voronoi = new Voronoi(); // Erase mesh
|
|
tempShowCells = true;
|
|
fileModeTSP = false;
|
|
}
|
|
|
|
void setup() {
|
|
borderWidth = 6;
|
|
mainwidth = 800;
|
|
mainheight = 600;
|
|
ctrlheight = 110;
|
|
fillingCircles = true;
|
|
|
|
size(800, 710);
|
|
|
|
gfx = new ToxiclibsSupport(this);
|
|
|
|
lowBorderX = borderWidth; //mainwidth*0.01;
|
|
hiBorderX = mainwidth - borderWidth; //mainwidth*0.98;
|
|
lowBorderY = borderWidth; // mainheight*0.01;
|
|
hiBorderY = mainheight - borderWidth; //mainheight*0.98;
|
|
|
|
int innerWidth = mainwidth - 2 * borderWidth;
|
|
int innerHeight = mainheight - 2 * borderWidth;
|
|
|
|
Rect rect = new Rect(lowBorderX, lowBorderY, innerWidth, innerHeight);
|
|
clip = new SutherlandHodgemanClipper(rect);
|
|
|
|
MainArraySetup(); // Main particle array setup
|
|
|
|
frameRate(24);
|
|
smooth();
|
|
noStroke();
|
|
fill(153); // Background fill color, for control section
|
|
|
|
textFont(createFont("SansSerif", 10));
|
|
|
|
cp5 = new ControlP5(this);
|
|
|
|
int leftcolumwidth = 225;
|
|
int guiTop = mainheight + 15;
|
|
int gui2ndRow = 4; // Spacing for firt row after group heading
|
|
int guiRowSpacing = 14; // Spacing for subsequent rows
|
|
int buttonHeight = mainheight + 19 + int(round(2.25 * guiRowSpacing));
|
|
|
|
ControlGroup l3 = cp5.addGroup("Primary controls (Changing will restart)", 10, guiTop, 225);
|
|
|
|
cp5.addSlider("sliderStipples", 10, 10000, maxParticles, 10, gui2ndRow, 150, 10)
|
|
.setGroup(l3);
|
|
|
|
cp5.addButton("buttonInvertImg", 10, 10, gui2ndRow + guiRowSpacing, 190, 10)
|
|
.setCaptionLabel("Black stipples, White Background")
|
|
.setGroup(l3);
|
|
|
|
cp5.addButton("buttonLoadFile", 10, 10, buttonHeight, 175, 10)
|
|
.setCaptionLabel("LOAD IMAGE FILE (.PNG, .JPG, or .GIF)");
|
|
|
|
cp5.addButton("buttonQuit", 10, 205, buttonHeight, 30, 10)
|
|
.setCaptionLabel("Quit");
|
|
|
|
cp5.addButton("buttonSaveStipples", 10, 25, buttonHeight + guiRowSpacing, 160, 10)
|
|
.setCaptionLabel("Save Stipple File (.SVG format)");
|
|
|
|
cp5.addButton("buttonSavePath", 10, 25, buttonHeight + 2 * guiRowSpacing, 160, 10)
|
|
.setCaptionLabel("Save \"TSP\" Path (.SVG format)");
|
|
|
|
cp5.addButton("buttonFillCircles", 10, 10, buttonHeight + 3 * guiRowSpacing, 190, 10)
|
|
.setCaptionLabel("Generate Filled circles in output");
|
|
|
|
ControlGroup l5 = cp5.addGroup("Display Options - Updated on next generation", leftcolumwidth+50, guiTop, 225);
|
|
|
|
cp5.addSlider("sliderMinDotSize", .5, 8, 2, 10, 4, 140, 10)
|
|
.setCaptionLabel("Min. Dot Size")
|
|
.setValue(minDotSize)
|
|
.setGroup(l5);
|
|
|
|
cp5.addSlider("sliderDotSizeRange", 0, 20, 5, 10, 18, 140, 10)
|
|
.setCaptionLabel("Dot Size Range")
|
|
.setValue(dotSizeFactor)
|
|
.setGroup(l5);
|
|
|
|
cp5.addSlider("sliderWhiteCutoff", 0, 1, 0, 10, 32, 140, 10)
|
|
.setCaptionLabel("White Cutoff")
|
|
.setValue(cutoff)
|
|
.setGroup(l5);
|
|
|
|
cp5.addButton("buttonImgOnOff", 10, 10, 46, 90, 10)
|
|
.setCaptionLabel("Image BG >> Hide")
|
|
.setGroup(l5);
|
|
|
|
cp5.addButton("buttonCellsOnOff", 10, 110, 46, 90, 10)
|
|
.setCaptionLabel("Cells >> Hide")
|
|
.setGroup(l5);
|
|
|
|
cp5.addButton("buttonPause", 10, 10, 60, 190, 10)
|
|
.setCaptionLabel("Pause (to calculate TSP path)")
|
|
.setGroup(l5);
|
|
|
|
cp5.addButton("buttonOrderOnOff", 10, 10, 74, 190, 10)
|
|
.setCaptionLabel("Plotting path >> shown while paused")
|
|
.setGroup(l5);
|
|
|
|
textColumnStart = 2 * leftcolumwidth + 100;
|
|
maxDotSize = getMaxDotSize(minDotSize);
|
|
|
|
saveNow = false;
|
|
showBG = false;
|
|
showPath = true;
|
|
showCells = false;
|
|
pausemode = false;
|
|
invertImg = false;
|
|
fileLoaded = false;
|
|
reInitiallizeArray = false;
|
|
}
|
|
|
|
void fileSelected(File selection) {
|
|
if (selection == null) {
|
|
println("Window was closed or the user hit cancel.");
|
|
} else {
|
|
//println("User selected " + selection.getAbsolutePath());
|
|
|
|
String loadPath = selection.getAbsolutePath();
|
|
|
|
// If a file was selected, print path to file
|
|
println("Loaded file: " + loadPath);
|
|
|
|
String[] p = splitTokens(loadPath, ".");
|
|
String ext = p[p.length - 1].toLowerCase();
|
|
|
|
boolean fileOK = false;
|
|
fileOK = fileOK || ext.equals("gif");
|
|
fileOK = fileOK || ext.equals("jpg");
|
|
fileOK = fileOK || ext.equals("tga");
|
|
fileOK = fileOK || ext.equals("png");
|
|
|
|
println("File OK: " + fileOK);
|
|
|
|
if (fileOK) {
|
|
imgload = loadImage(loadPath);
|
|
fileLoaded = true;
|
|
reInitiallizeArray = true;
|
|
} else {
|
|
// Can't load file
|
|
errorDisplay = "ERROR: BAD FILE TYPE";
|
|
errorTime = millis();
|
|
errorDisp = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void buttonLoadFile(float theValue) {
|
|
println(":::LOAD JPG, GIF or PNG FILE:::");
|
|
selectInput("Select a file to process:", "fileSelected"); // Opens file chooser
|
|
}
|
|
|
|
void buttonSavePath(float theValue) {
|
|
fileModeTSP = true;
|
|
saveSvg(0);
|
|
}
|
|
|
|
void buttonSaveStipples(float theValue) {
|
|
fileModeTSP = false;
|
|
saveSvg(0);
|
|
}
|
|
|
|
void SavefileSelected(File selection) {
|
|
if (selection == null) {
|
|
// If a file was not selected
|
|
println("No output file was selected...");
|
|
errorDisplay = "ERROR: NO FILE NAME CHOSEN.";
|
|
errorTime = millis();
|
|
errorDisp = true;
|
|
} else {
|
|
savePath = selection.getAbsolutePath();
|
|
String[] p = splitTokens(savePath, ".");
|
|
boolean fileOK = p[p.length - 1].toLowerCase().equals("svg");
|
|
if (!fileOK) savePath = savePath + ".svg";
|
|
|
|
// If a file was selected, print path to folder
|
|
println("Save file: " + savePath);
|
|
saveNow = true;
|
|
showPath = true;
|
|
|
|
errorDisplay = "SAVING FILE...";
|
|
errorTime = millis();
|
|
errorDisp = true;
|
|
}
|
|
}
|
|
|
|
void saveSvg(float theValue) {
|
|
if (!pausemode) {
|
|
buttonPause(0.0);
|
|
errorDisplay = "Error: PAUSE before saving.";
|
|
errorTime = millis();
|
|
errorDisp = true;
|
|
} else {
|
|
selectOutput("Output .svg file name:", "SavefileSelected");
|
|
}
|
|
}
|
|
|
|
void buttonQuit(float theValue) {
|
|
exit();
|
|
}
|
|
|
|
void buttonOrderOnOff(float theValue) {
|
|
Button orderOnOff = (Button)cp5.getController("buttonOrderOnOff");
|
|
if (showPath) {
|
|
showPath = false;
|
|
orderOnOff.setCaptionLabel("Plotting path >> Hide");
|
|
} else {
|
|
showPath = true;
|
|
orderOnOff.setCaptionLabel("Plotting path >> Shown while paused");
|
|
}
|
|
}
|
|
|
|
void buttonCellsOnOff(float theValue) {
|
|
Button cellsOnOff = (Button)cp5.getController("buttonCellsOnOff");
|
|
if (showCells) {
|
|
showCells = false;
|
|
cellsOnOff.setCaptionLabel("Cells >> Hide");
|
|
} else {
|
|
showCells = true;
|
|
cellsOnOff.setCaptionLabel("Cells >> Show");
|
|
}
|
|
}
|
|
|
|
void buttonImgOnOff(float theValue) {
|
|
Button imgOnOffButton = (Button)cp5.getController("buttonImgOnOff");
|
|
if (showBG) {
|
|
showBG = false;
|
|
imgOnOffButton.setCaptionLabel("Image BG >> Hide");
|
|
} else {
|
|
showBG = true;
|
|
imgOnOffButton.setCaptionLabel("Image BG >> Show");
|
|
}
|
|
}
|
|
|
|
void buttonInvertImg(float theValue) {
|
|
Slider cutoffSlider = (Slider)cp5.getController("sliderWhiteCutoff");
|
|
Button invertImgButton = (Button)cp5.getController("buttonInvertImg");
|
|
if (invertImg) {
|
|
invertImg = false;
|
|
invertImgButton.setCaptionLabel("Black stipples, White background");
|
|
cutoffSlider.setCaptionLabel("White Cutoff");
|
|
} else {
|
|
invertImg = true;
|
|
invertImgButton.setCaptionLabel("White stipples, Black background");
|
|
cutoffSlider.setCaptionLabel("Black Cutoff");
|
|
}
|
|
|
|
reInitiallizeArray = true;
|
|
pausemode = false;
|
|
}
|
|
|
|
void buttonFillCircles(float theValue) {
|
|
Button fillCircleButton = (Button)cp5.getController("buttonFillCircles");
|
|
if (fillingCircles) {
|
|
fillingCircles = false;
|
|
fillCircleButton.setCaptionLabel("Generate Open circles in output");
|
|
} else {
|
|
fillingCircles = true;
|
|
fillCircleButton.setCaptionLabel("Generate Filled circles in output");
|
|
}
|
|
}
|
|
|
|
void buttonPause(float theValue) {
|
|
// Main particle array setup (to be repeated if necessary):
|
|
Button pauseButton = (Button)cp5.getController("buttonPause");
|
|
if (pausemode) {
|
|
pausemode = false;
|
|
println("Resuming.");
|
|
pauseButton.setCaptionLabel("Pause (to calculate TSP path)");
|
|
} else {
|
|
pausemode = true;
|
|
println("Paused. Press PAUSE again to resume.");
|
|
pauseButton.setCaptionLabel("Paused (calculating TSP path)");
|
|
}
|
|
routeStep = 0;
|
|
}
|
|
|
|
boolean overRect(int x, int y, int width, int height) {
|
|
return mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + height;
|
|
}
|
|
|
|
void sliderStipples(int inValue) {
|
|
if (maxParticles != inValue) {
|
|
println("Update: Stipple Count -> " + inValue);
|
|
reInitiallizeArray = true;
|
|
pausemode = false;
|
|
}
|
|
}
|
|
|
|
void sliderMinDotSize(float inValue) {
|
|
if (minDotSize != inValue) {
|
|
println("Update: sliderMinDotSize -> " + inValue);
|
|
minDotSize = inValue;
|
|
maxDotSize = getMaxDotSize(minDotSize);
|
|
}
|
|
}
|
|
|
|
void sliderDotSizeRange(float inValue) {
|
|
if (dotSizeFactor != inValue) {
|
|
println("Update: Dot Size Range -> " + inValue);
|
|
dotSizeFactor = inValue;
|
|
maxDotSize = getMaxDotSize(minDotSize);
|
|
}
|
|
}
|
|
|
|
void sliderWhiteCutoff(float inValue) {
|
|
if (cutoff != inValue) {
|
|
println("Update: White_Cutoff -> " + inValue);
|
|
cutoff = inValue;
|
|
routeStep = 0; // Reset TSP path
|
|
}
|
|
}
|
|
|
|
float getMaxDotSize(float minDotSize) {
|
|
return minDotSize * (1 + dotSizeFactor);
|
|
}
|
|
|
|
void doBackgrounds() {
|
|
if (showBG) {
|
|
image(img, 0, 0); // Show original (cropped and scaled, but not blurred!) image in background
|
|
} else {
|
|
fill(invertImg ? 0 : 255);
|
|
rect(0, 0, mainwidth, mainheight);
|
|
}
|
|
}
|
|
|
|
void optimizePlotPath() {
|
|
int temp;
|
|
// Calculate and show "optimized" plotting path, beneath points.
|
|
|
|
statusDisplay = "Optimizing plotting path";
|
|
/*
|
|
if (routeStep % 100 == 0) {
|
|
println("RouteStep:" + routeStep);
|
|
println("fps = " + frameRate );
|
|
}
|
|
*/
|
|
|
|
Vec2D p1;
|
|
|
|
if (routeStep == 0) {
|
|
float cutoffScaled = 1 - cutoff;
|
|
// Begin process of optimizing plotting route, by flagging particles that will be shown.
|
|
|
|
particleRouteLength = 0;
|
|
|
|
boolean particleRouteTemp[] = new boolean[maxParticles];
|
|
|
|
for (int i = 0; i < maxParticles; ++i) {
|
|
particleRouteTemp[i] = false;
|
|
|
|
int px = (int) particles[i].x;
|
|
int py = (int) particles[i].y;
|
|
|
|
if ((px >= imgblur.width) || (py >= imgblur.height) || (px < 0) || (py < 0)) {
|
|
continue;
|
|
}
|
|
|
|
float v = (brightness(imgblur.pixels[py * imgblur.width + px])) / 255;
|
|
|
|
if (invertImg) {
|
|
v = 1 - v;
|
|
}
|
|
|
|
if (v < cutoffScaled) {
|
|
particleRouteTemp[i] = true;
|
|
particleRouteLength++;
|
|
}
|
|
}
|
|
|
|
particleRoute = new int[particleRouteLength];
|
|
int tempCounter = 0;
|
|
for (int i = 0; i < maxParticles; ++i) {
|
|
if (particleRouteTemp[i]) {
|
|
particleRoute[tempCounter] = i;
|
|
tempCounter++;
|
|
}
|
|
}
|
|
// These are the ONLY points to be drawn in the tour.
|
|
}
|
|
|
|
if (routeStep < (particleRouteLength - 2)) {
|
|
// Nearest neighbor ("Simple, Greedy") algorithm path optimization:
|
|
|
|
int StopPoint = routeStep + 1000; // 1000 steps per frame displayed; you can edit this number!
|
|
|
|
if (StopPoint > (particleRouteLength - 1)) {
|
|
StopPoint = particleRouteLength - 1;
|
|
}
|
|
|
|
for (int i = routeStep; i < StopPoint; ++i) {
|
|
p1 = particles[particleRoute[routeStep]];
|
|
int ClosestParticle = 0;
|
|
float distMin = Float.MAX_VALUE;
|
|
|
|
for (int j = routeStep + 1; j < (particleRouteLength - 1); ++j) {
|
|
Vec2D p2 = particles[particleRoute[j]];
|
|
|
|
float dx = p1.x - p2.x;
|
|
float dy = p1.y - p2.y;
|
|
float distance = (float) (dx*dx+dy*dy); // Only looking for closest; do not need sqrt factor!
|
|
|
|
if (distance < distMin) {
|
|
ClosestParticle = j;
|
|
distMin = distance;
|
|
}
|
|
}
|
|
|
|
temp = particleRoute[routeStep + 1];
|
|
// p1 = particles[particleRoute[routeStep + 1]];
|
|
particleRoute[routeStep + 1] = particleRoute[ClosestParticle];
|
|
particleRoute[ClosestParticle] = temp;
|
|
|
|
if (routeStep < (particleRouteLength - 1)) {
|
|
routeStep++;
|
|
} else {
|
|
println("Now optimizing plot path" );
|
|
}
|
|
}
|
|
} else { // Initial routing is complete
|
|
// 2-opt heuristic optimization:
|
|
// Identify a pair of edges that would become shorter by reversing part of the tour.
|
|
|
|
for (int i = 0; i < 90000; ++i) { // 1000 tests per frame; you can edit this number.
|
|
int indexA = floor(random(particleRouteLength - 1));
|
|
int indexB = floor(random(particleRouteLength - 1));
|
|
|
|
if (Math.abs(indexA - indexB) < 2) {
|
|
continue;
|
|
}
|
|
|
|
if (indexB < indexA) { // swap A, B.
|
|
temp = indexB;
|
|
indexB = indexA;
|
|
indexA = temp;
|
|
}
|
|
|
|
Vec2D a0 = particles[particleRoute[indexA]];
|
|
Vec2D a1 = particles[particleRoute[indexA + 1]];
|
|
Vec2D b0 = particles[particleRoute[indexB]];
|
|
Vec2D b1 = particles[particleRoute[indexB + 1]];
|
|
|
|
// Original distance:
|
|
float dx = a0.x - a1.x;
|
|
float dy = a0.y - a1.y;
|
|
float distance = (float)(dx*dx+dy*dy); // Only a comparison; do not need sqrt factor!
|
|
dx = b0.x - b1.x;
|
|
dy = b0.y - b1.y;
|
|
distance += (float)(dx*dx+dy*dy); // Only a comparison; do not need sqrt factor!
|
|
|
|
// Possible shorter distance?
|
|
dx = a0.x - b0.x;
|
|
dy = a0.y - b0.y;
|
|
float distance2 = (float)(dx*dx+dy*dy); // Only a comparison; do not need sqrt factor!
|
|
dx = a1.x - b1.x;
|
|
dy = a1.y - b1.y;
|
|
distance2 += (float)(dx*dx+dy*dy); // Only a comparison; do not need sqrt factor!
|
|
|
|
if (distance2 < distance) {
|
|
// Reverse tour between a1 and b0.
|
|
|
|
int indexhigh = indexB;
|
|
int indexlow = indexA + 1;
|
|
|
|
// println("Shorten!" + frameRate );
|
|
|
|
while (indexhigh > indexlow) {
|
|
temp = particleRoute[indexlow];
|
|
particleRoute[indexlow] = particleRoute[indexhigh];
|
|
particleRoute[indexhigh] = temp;
|
|
|
|
indexhigh--;
|
|
indexlow++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
frameTime = (millis() - millisLastFrame) / 1000;
|
|
millisLastFrame = millis();
|
|
}
|
|
|
|
void doPhysics() { // Iterative relaxation via weighted Lloyd's algorithm.
|
|
int temp;
|
|
int CountTemp;
|
|
|
|
if (!voronoiCalculated) {
|
|
// Part I: Calculate voronoi cell diagram of the points.
|
|
|
|
statusDisplay = "Calculating Voronoi diagram ";
|
|
|
|
// float millisBaseline = millis(); // Baseline for timing studies
|
|
// println("Baseline. Time = " + (millis() - millisBaseline) );
|
|
|
|
if (vorPointsAdded == 0) {
|
|
voronoi = new Voronoi(); // Erase mesh
|
|
}
|
|
|
|
temp = vorPointsAdded + 500; // This line: VoronoiPointsPerPass (Feel free to edit this number.)
|
|
if (temp > maxParticles) {
|
|
temp = maxParticles;
|
|
}
|
|
|
|
for (int i = vorPointsAdded; i < temp; i++) {
|
|
// Optional, for diagnostics:::
|
|
// println("particles[i].x, particles[i].y " + particles[i].x + ", " + particles[i].y );
|
|
|
|
voronoi.addPoint(new Vec2D(particles[i].x, particles[i].y ));
|
|
vorPointsAdded++;
|
|
}
|
|
|
|
if (vorPointsAdded >= maxParticles) {
|
|
// println("Points added. Time = " + (millis() - millisBaseline) );
|
|
|
|
cellsTotal = voronoi.getRegions().size();
|
|
vorPointsAdded = 0;
|
|
cellsCalculated = 0;
|
|
cellsCalculatedLast = 0;
|
|
|
|
regionList = new Polygon2D[cellsTotal];
|
|
|
|
int i = 0;
|
|
for (Polygon2D poly : voronoi.getRegions()) {
|
|
regionList[i++] = poly; // Build array of polygons
|
|
}
|
|
voronoiCalculated = true;
|
|
}
|
|
} else { // Part II: Calculate weighted centroids of cells.
|
|
// float millisBaseline = millis();
|
|
// println("fps = " + frameRate );
|
|
|
|
statusDisplay = "Calculating weighted centroids";
|
|
|
|
temp = cellsCalculated + 500; // This line: CentroidsPerPass (Feel free to edit this number.)
|
|
// Higher values give slightly faster computation, but a less responsive GUI.
|
|
// Default value: 500
|
|
|
|
// Time/frame @ 100: 2.07 @ 50 frames in
|
|
// Time/frame @ 200: 1.575 @ 50
|
|
// Time/frame @ 500: 1.44 @ 50
|
|
|
|
if (temp > cellsTotal) {
|
|
temp = cellsTotal;
|
|
}
|
|
|
|
for (int i=cellsCalculated; i< temp; i++) {
|
|
float xMax = 0;
|
|
float xMin = mainwidth;
|
|
float yMax = 0;
|
|
float yMin = mainheight;
|
|
float xt, yt;
|
|
|
|
Polygon2D region = clip.clipPolygon(regionList[i]);
|
|
|
|
for (Vec2D v : region.vertices) {
|
|
xt = v.x;
|
|
yt = v.y;
|
|
|
|
if (xt < xMin) xMin = xt;
|
|
if (xt > xMax) xMax = xt;
|
|
if (yt < yMin) yMin = yt;
|
|
if (yt > yMax) yMax = yt;
|
|
}
|
|
|
|
float xDiff = xMax - xMin;
|
|
float yDiff = yMax - yMin;
|
|
float maxSize = max(xDiff, yDiff);
|
|
float minSize = min(xDiff, yDiff);
|
|
|
|
float scaleFactor = 1.0;
|
|
|
|
// Maximum voronoi cell extent should be between
|
|
// cellBuffer/2 and cellBuffer in size.
|
|
|
|
while (maxSize > cellBuffer) {
|
|
scaleFactor *= 0.5;
|
|
maxSize *= 0.5;
|
|
}
|
|
|
|
while (maxSize < (cellBuffer / 2)) {
|
|
scaleFactor *= 2;
|
|
maxSize *= 2;
|
|
}
|
|
|
|
if ((minSize * scaleFactor) > (cellBuffer/2)) {
|
|
// Special correction for objects of near-unity (square-like) aspect ratio,
|
|
// which have larger area *and* where it is less essential to find the exact centroid:
|
|
scaleFactor *= 0.5;
|
|
}
|
|
|
|
float StepSize = (1/scaleFactor);
|
|
|
|
float xSum = 0;
|
|
float ySum = 0;
|
|
float dSum = 0;
|
|
float PicDensity = 1.0;
|
|
|
|
if (invertImg) {
|
|
for (float x=xMin; x<=xMax; x += StepSize) {
|
|
for (float y=yMin; y<=yMax; y += StepSize) {
|
|
Vec2D p0 = new Vec2D(x, y);
|
|
if (region.containsPoint(p0)) {
|
|
// Thanks to polygon clipping, NO vertices will be beyond the sides of imgblur.
|
|
PicDensity = 0.001 + (brightness(imgblur.pixels[ round(y)*imgblur.width + round(x) ]));
|
|
|
|
xSum += PicDensity * x;
|
|
ySum += PicDensity * y;
|
|
dSum += PicDensity;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (float x=xMin; x<=xMax; x += StepSize) {
|
|
for (float y=yMin; y<=yMax; y += StepSize) {
|
|
Vec2D p0 = new Vec2D(x, y);
|
|
if (region.containsPoint(p0)) {
|
|
// Thanks to polygon clipping, NO vertices will be beyond the sides of imgblur.
|
|
PicDensity = 255.001 - (brightness(imgblur.pixels[ round(y)*imgblur.width + round(x) ]));
|
|
|
|
xSum += PicDensity * x;
|
|
ySum += PicDensity * y;
|
|
dSum += PicDensity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dSum > 0) {
|
|
xSum /= dSum;
|
|
ySum /= dSum;
|
|
}
|
|
|
|
Vec2D centr;
|
|
|
|
float xTemp = xSum;
|
|
float yTemp = ySum;
|
|
|
|
if ((xTemp <= lowBorderX) || (xTemp >= hiBorderX) || (yTemp <= lowBorderY) || (yTemp >= hiBorderY)) {
|
|
// If new centroid is computed to be outside the visible region, use the geometric centroid instead.
|
|
// This will help to prevent runaway points due to numerical artifacts.
|
|
centr = region.getCentroid();
|
|
xTemp = centr.x;
|
|
yTemp = centr.y;
|
|
|
|
// Enforce sides, if absolutely necessary: (Failure to do so *will* cause a crash, eventually.)
|
|
|
|
if (xTemp <= lowBorderX) xTemp = lowBorderX + 1;
|
|
if (xTemp >= hiBorderX) xTemp = hiBorderX - 1;
|
|
if (yTemp <= lowBorderY) yTemp = lowBorderY + 1;
|
|
if (yTemp >= hiBorderY) yTemp = hiBorderY - 1;
|
|
}
|
|
|
|
particles[i].x = xTemp;
|
|
particles[i].y = yTemp;
|
|
|
|
cellsCalculated++;
|
|
}
|
|
|
|
// println("cellsCalculated = " + cellsCalculated );
|
|
// println("cellsTotal = " + cellsTotal );
|
|
|
|
if (cellsCalculated >= cellsTotal) {
|
|
voronoiCalculated = false;
|
|
generation++;
|
|
println("Generation = " + generation );
|
|
|
|
frameTime = (millis() - millisLastFrame)/1000;
|
|
millisLastFrame = millis();
|
|
}
|
|
}
|
|
}
|
|
|
|
String makeSpiral ( float xOrigin, float yOrigin, float turns, float radius)
|
|
{
|
|
float resolution = 20.0;
|
|
|
|
float AngleStep = TAU / resolution;
|
|
float ScaledRadiusPerTurn = radius / (TAU * turns);
|
|
|
|
String spiralSVG = "<path d=\"M " + xOrigin + "," + yOrigin + " "; // Mark center point of spiral
|
|
|
|
float x, y;
|
|
float angle = 0;
|
|
|
|
int stopPoint = ceil (resolution * turns);
|
|
int startPoint = floor(resolution / 4); // Skip the first quarter turn in the spiral, since we have a center point already.
|
|
|
|
if (turns > 1.0) { // For small enough circles, skip the fill, and just draw the circle.
|
|
for (int i = startPoint; i <= stopPoint; i = i+1) {
|
|
angle = i * AngleStep;
|
|
x = xOrigin + ScaledRadiusPerTurn * angle * cos(angle);
|
|
y = yOrigin + ScaledRadiusPerTurn * angle * sin(angle);
|
|
spiralSVG += x + "," + y + " ";
|
|
}
|
|
}
|
|
|
|
// Last turn is a circle:
|
|
float CircleRad = ScaledRadiusPerTurn * angle;
|
|
|
|
for (int i = 0; i <= resolution; i = i+1) {
|
|
angle += AngleStep;
|
|
x = xOrigin + radius * cos(angle);
|
|
y = yOrigin + radius * sin(angle);
|
|
|
|
spiralSVG += x + "," + y + " ";
|
|
}
|
|
|
|
spiralSVG += "\" />" ;
|
|
return spiralSVG;
|
|
}
|
|
|
|
void draw() {
|
|
int i = 0;
|
|
int temp;
|
|
float dotScale = (maxDotSize - minDotSize);
|
|
float cutoffScaled = 1 - cutoff;
|
|
|
|
if (reInitiallizeArray) {
|
|
// Only change maxParticles here!
|
|
maxParticles = (int)cp5.getController("sliderStipples").getValue();
|
|
MainArraySetup();
|
|
reInitiallizeArray = false;
|
|
}
|
|
|
|
if (pausemode && !voronoiCalculated) {
|
|
optimizePlotPath();
|
|
} else {
|
|
doPhysics();
|
|
}
|
|
|
|
if (pausemode) {
|
|
doBackgrounds();
|
|
|
|
// Draw paths:
|
|
|
|
if (showPath) {
|
|
stroke(128, 128, 255); // Stroke color (blue)
|
|
strokeWeight (1);
|
|
|
|
for (i = 0; i < particleRouteLength - 1; ++i) {
|
|
Vec2D p1 = particles[particleRoute[i]];
|
|
Vec2D p2 = particles[particleRoute[i + 1]];
|
|
line(p1.x, p1.y, p2.x, p2.y);
|
|
}
|
|
}
|
|
|
|
stroke(invertImg ? 255 : 0);
|
|
fill (invertImg ? 0 : 255);
|
|
strokeWeight(1);
|
|
|
|
for ( i = 0; i < particleRouteLength; ++i) {
|
|
// Only show "routed" particles-- those above the white cutoff.
|
|
|
|
Vec2D p1 = particles[particleRoute[i]];
|
|
int px = (int)p1.x;
|
|
int py = (int)p1.y;
|
|
|
|
float v = (brightness(imgblur.pixels[py * imgblur.width + px])) / 255;
|
|
|
|
if (invertImg) v = 1 - v;
|
|
|
|
if (fillingCircles) {
|
|
strokeWeight(maxDotSize - v * dotScale);
|
|
point(px, py);
|
|
} else {
|
|
float dotSize = maxDotSize - v * dotScale;
|
|
ellipse(px, py, dotSize, dotSize);
|
|
}
|
|
}
|
|
} else { // NOT in pause mode. i.e., just displaying stipples.
|
|
if (cellsCalculated == 0) {
|
|
doBackgrounds();
|
|
|
|
tempShowCells = generation == 0;
|
|
|
|
if (showCells || tempShowCells) { // Draw voronoi cells, over background.
|
|
strokeWeight(1);
|
|
noFill();
|
|
|
|
stroke(invertImg && !showBG ? 100 : 200);
|
|
|
|
i = 0;
|
|
for (Polygon2D poly : voronoi.getRegions()) {
|
|
//regionList[i++] = poly;
|
|
gfx.polygon2D(clip.clipPolygon(poly));
|
|
}
|
|
}
|
|
|
|
if (showCells) {
|
|
// Show "before and after" centroids, when polygons are shown.
|
|
|
|
strokeWeight(minDotSize); // Normal w/ Min & Max dot size
|
|
for ( i = 0; i < maxParticles; ++i) {
|
|
|
|
int px = (int)particles[i].x;
|
|
int py = (int)particles[i].y;
|
|
|
|
if ((px >= imgblur.width) || (py >= imgblur.height) || (px < 0) || (py < 0))
|
|
continue;
|
|
{
|
|
//Uncomment the following four lines, if you wish to display the "before" dots at weighted sizes.
|
|
//float v = (brightness(imgblur.pixels[ py*imgblur.width + px ]))/255;
|
|
//if (invertImg)
|
|
//v = 1 - v;
|
|
//strokeWeight (maxDotSize - v * dotScale);
|
|
point(px, py);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Stipple calculation is still underway
|
|
|
|
if (tempShowCells) {
|
|
doBackgrounds();
|
|
tempShowCells = false;
|
|
}
|
|
|
|
stroke(invertImg ? 255 : 0);
|
|
fill(invertImg ? 0 : 255);
|
|
strokeWeight(1);
|
|
|
|
for (i = cellsCalculatedLast; i < cellsCalculated; ++i) {
|
|
int px = (int)particles[i].x;
|
|
int py = (int)particles[i].y;
|
|
|
|
if ((px >= imgblur.width) || (py >= imgblur.height) || (px < 0) || (py < 0))
|
|
continue;
|
|
{
|
|
float v = (brightness(imgblur.pixels[py * imgblur.width + px])) / 255;
|
|
|
|
if (invertImg) v = 1 - v;
|
|
|
|
if (v < cutoffScaled) {
|
|
if (fillingCircles) {
|
|
strokeWeight(maxDotSize - v * dotScale);
|
|
point(px, py);
|
|
} else {
|
|
float dotSize = maxDotSize - v * dotScale;
|
|
ellipse(px, py, dotSize, dotSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
cellsCalculatedLast = cellsCalculated;
|
|
}
|
|
}
|
|
|
|
noStroke();
|
|
fill(100); // Background fill color
|
|
rect(0, mainheight, mainwidth, height); // Control area fill
|
|
|
|
// Underlay for hyperlink:
|
|
if (overRect(textColumnStart - 10, mainheight + 35, 205, 20) ) {
|
|
fill(150);
|
|
rect(textColumnStart - 10, mainheight + 35, 205, 20);
|
|
}
|
|
|
|
fill(255); // Text color
|
|
|
|
text("StippleGen 2 (v. 2.4.0)", textColumnStart, mainheight + 15);
|
|
text("by Evil Mad Scientist Laboratories", textColumnStart, mainheight + 30);
|
|
text("www.evilmadscientist.com/go/stipple2", textColumnStart, mainheight + 50);
|
|
|
|
text("Generations completed: " + generation, textColumnStart, mainheight + 85);
|
|
text("Time/Frame: " + frameTime + " s", textColumnStart, mainheight + 100);
|
|
|
|
if (errorDisp) {
|
|
fill(255, 0, 0); // Text color
|
|
text(errorDisplay, textColumnStart, mainheight + 70);
|
|
errorDisp = !(millis() - errorTime > 8000);
|
|
} else {
|
|
text("Status: " + statusDisplay, textColumnStart, mainheight + 70);
|
|
}
|
|
|
|
if (saveNow) {
|
|
statusDisplay = "Saving SVG File";
|
|
saveNow = false;
|
|
|
|
fileOutput = loadStrings("header.txt");
|
|
|
|
String rowTemp;
|
|
|
|
float SVGscale = (800.0 / (float) mainheight);
|
|
int xOffset = (int)(1600 - (SVGscale * mainwidth / 2));
|
|
int yOffset = (int)(400 - (SVGscale * mainheight / 2));
|
|
|
|
if (fileModeTSP) { // Plot the PATH between the points only.
|
|
println("Save TSP File (SVG)");
|
|
|
|
// Path header::
|
|
rowTemp = "<path style=\"fill:none;stroke:black;stroke-width:2px;stroke-linejoin:round;stroke-linecap:round;\" d=\"M ";
|
|
fileOutput = append(fileOutput, rowTemp);
|
|
|
|
for (i = 0; i < particleRouteLength; ++i) {
|
|
Vec2D p1 = particles[particleRoute[i]];
|
|
|
|
float xTemp = SVGscale * p1.x + xOffset;
|
|
float yTemp = SVGscale * p1.y + yOffset;
|
|
|
|
rowTemp = xTemp + " " + yTemp + "\r";
|
|
fileOutput = append(fileOutput, rowTemp);
|
|
}
|
|
fileOutput = append(fileOutput, "\" />"); // End path description
|
|
} else {
|
|
println("Save Stipple File (SVG)");
|
|
|
|
for (i = 0; i < particleRouteLength; ++i) {
|
|
Vec2D p1 = particles[particleRoute[i]];
|
|
|
|
int px = floor(p1.x);
|
|
int py = floor(p1.y);
|
|
|
|
float v = (brightness(imgblur.pixels[py * imgblur.width + px])) / 255;
|
|
|
|
if (invertImg) v = 1 - v;
|
|
|
|
float dotrad = (maxDotSize - v * dotScale) / 2;
|
|
|
|
float xTemp = SVGscale * p1.x + xOffset;
|
|
float yTemp = SVGscale * p1.y + yOffset;
|
|
|
|
if (fillingCircles) {
|
|
rowTemp = makeSpiral(xTemp, yTemp, dotrad / 2.0, dotrad);
|
|
} else {
|
|
rowTemp = "<circle cx=\"" + xTemp + "\" cy=\"" + yTemp + "\" r=\"" + dotrad + "\"/> ";
|
|
}
|
|
//Typ: <circle cx="1600" cy="450" r="3" />
|
|
|
|
fileOutput = append(fileOutput, rowTemp);
|
|
}
|
|
}
|
|
|
|
// SVG footer:
|
|
fileOutput = append(fileOutput, "</g></g></svg>");
|
|
saveStrings(savePath, fileOutput);
|
|
fileModeTSP = false; // reset for next time
|
|
|
|
if (fileModeTSP) {
|
|
errorDisplay = "TSP Path .SVG file Saved";
|
|
} else {
|
|
errorDisplay = "Stipple .SVG file saved ";
|
|
}
|
|
|
|
errorTime = millis();
|
|
errorDisp = true;
|
|
}
|
|
}
|
|
|
|
void mousePressed() {
|
|
// rect(textColumnStart, mainheight, 200, 75);
|
|
if (overRect(textColumnStart - 15, mainheight + 35, 205, 20) ) {
|
|
link("http://www.evilmadscientist.com/go/stipple2");
|
|
}
|
|
}
|
|
|
|
void keyPressed() {
|
|
if (key == 'x') { // If this program doesn't run slowly enough for you,
|
|
// simply press the 'x' key on your keyboard. :)
|
|
cp5.getController("sliderStipples").setMax(50000.0);
|
|
}
|
|
}
|