Processing Forum

Screen name:
frederickk
Blog:
http://kenfrederick.blogspot.com/
Website:
http://cargocollective.com/kenfrederick/

frederickk's Profile

4 Posts

5 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

finding nearest neighbor & point to point morphing (transitioning)

[10 Replies]
- 28-Aug-2011 10:05 AM
- Forum: Programming Questions
i'm trying to use two arrays of PVector points and compare and match them up based on the proximity of the points to each other.

so in Array A i have a collection of points
1. PVector[] pointListA = {
2. new PVector(0,0),
3. new PVector(20,10),
4. new PVector(30,20),
5. new PVector(40,60)
6. };
and then i create an Array B with new points.
PVector[] pointListB = {

new PVector(10,0),

new PVector(30,0),

new PVector(50,20),

new PVector(20,10)

};
i would go through the lists of arrays and based on distance and pair the the arrays up so that the points closest to one another are correlated.

after "matching" up the arrays the ideas is that i would then "lerp" the a points pointListA to their corresponding point of pointListB.

and then repeat.

essentially morphing a set of points into the other

i've been racking my brain trying to get this to work. but thus i've been unable to get it to work exactly how i want. i borrowed some code and thinking from
PhiLho
http://processing.org/discourse/yabb2/YaBB.pl?num=1244097116

here's some "simplified" code of what i have working thus far but as you'll see it seems to find the nearest points, but then instead of "transitioning" from point to point it seems like the points get reduced. and after 10seconds all of the points have the same coordinates

i'm explaining this in a terrible way, so i hope someone out there understands what i'm looking for and can help.
//-----------------------------------------------------------------------------

// properties

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

FPointSet fpoints;

ArrayList npoints;

void setup() {

size(720,480);

//smooth();

initialize();

}

void draw() {

background(0);

/*

* points

*/

fpoints.update();

fpoints.draw();

if( !fpoints.running() ) {

next();

}

}

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

// methods

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

void initialize() {

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

// points

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

//fpoints = new ArrayList();

fpoints = new FPointSet();

npoints = new ArrayList();



//start out with 20 random points

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

FPoint fp = new FPoint( new PVector(random(width), random(height)) );

fpoints.add(fp);

}

next();

}

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

void next() {

npoints = createRandom(20);

fpoints.findNearest(npoints);

}

/*

* create NUM random points

*/

ArrayList createRandom(int num) {

ArrayList newPoints = new ArrayList();

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

newPoints.add(new PVector(random(width), random(height) ));

}

return newPoints;

}

/**

* class for defining and finding a list of nearest points

* witin a series of points modified from http://processing.org/discourse/yabb2/YaBB.pl?num=1244097116

*

* Define a neighbour node:

* distance to initial point and reference to the goto point

*/

public class NearPoint {

float dist;

PVector pos = new PVector();

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

// Constructor

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

public NearPoint() {

// Initialize with the biggest distance we can have

dist = Float.MAX_VALUE;

}

public NearPoint(float d, PVector _pos) {

dist = d;

pos = _pos.get();

}

}

class NearPoints {

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

// Properties

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

public LinkedList nearest = new LinkedList();

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

// Constructor

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

public NearPoints(int num) {

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

// Initialize with empty far nodes

NearPoint nn = new NearPoint();

nearest.add(nn);

}

}

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

// Methods

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

/**

* The algorithm to test if given node is closer than the stored ones

*/

public void CheckDist(float d, PVector n) {

/*

* First node is always the farthest,

* we keep the linked list sorted

* (by inserting at the right place)

*/

NearPoint fnn = (NearPoint) nearest.getFirst();

if (d < fnn.dist) {

// Found an element closer

// Remove the far element

nearest.remove();

// To add

NearPoint nnn = new NearPoint(d, n);

// Walk the list until we find a node which is farther than this one

Iterator it = nearest.iterator();

int index = -1;

while (it.hasNext ()) {

NearPoint nn = (NearPoint) it.next();

index++;

if (d > nn.dist) {

// Found, we add the node before this one

nearest.add(index, nnn);

return;

}

}

// Not found, ie. found the smallest distance, put it at end

nearest.add(nnn);

}

}

}

/**

* a point class that makes easing and tweening

* much easier

*/

public class FPoint {

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

// properties

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

public PVector pos = new PVector();

protected PVector destination = new PVector();

private boolean bArrived = false;

private float lerpAmt = 0.0f;

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

// constructor

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

public FPoint(PVector _pos) {

//new points initialized with same pos and destination

pos = _pos.get();

setDestination(pos);

}

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

// methods

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

public void update() {

if(lerpAmt >= 1.0) {

bArrived = true;

pos = destination.get();

//destination = null;

} else {

lerpAmt += 0.01;

pos = plerp(pos,destination, lerpAmt);

bArrived = false;

}

}

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

public void reset() {

bArrived = false;

lerpAmt = 0.0;

}

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

PVector plerp(PVector pt1, PVector pt2, float amt) {

float x = lerp(pt1.x, pt2.x, amt);

float y = lerp(pt1.y, pt2.y, amt);

return new PVector(x,y);

}

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

// sets

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

public void setDestination(PVector _dest) {

if(_dest != destination) reset();

destination = _dest.get();

}

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

// gets

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

public boolean arrived() {

return bArrived;

}

}

public class FPointSet {

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

// properties

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

protected ArrayList fpoints = new ArrayList();

public int size = 0;

private boolean bRunning = true;



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

// constructor

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

public FPointSet() {

}

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

// methods

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

public void update() {

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

FPoint fp = (FPoint) fpoints.get(i);

fp.update();



if(fp.arrived()) bRunning = false;

else bRunning = true;

}

}

public void draw() {

noFill();

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

FPoint fp = (FPoint) fpoints.get(i);

//points

PVector pt1 = fp.pos;

stroke(0,255,255);

point(pt1.x,pt1.y);



PVector pt2 = fp.destination;

stroke(255,0,255);

ellipse(pt2.x,pt2.y, 9,9);



//line

strokeWeight(1);

stroke(255, norm(i,0,fpoints.size())*255, 0);

line(pt1.x,pt1.y, pt2.x,pt2.y);

}

}

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

public void findNearest(ArrayList npointSet) {

int num = fpoints.size();



// create a list of nearest points

NearPoints nearPoints = new NearPoints(num);



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

FPoint fp = (FPoint) fpoints.get(i);

PVector fpt = fp.pos;



for (int j=0; j<npointSet.size(); j++) {

PVector npt = (PVector) npointSet.get(j);

// Check if closer than the previous checked one

// and if so, replace the farthest

nearPoints.CheckDist(fpt.dist(npt), fpt);

}

}



println(fpoints.size() + " --VS-- " + nearPoints.nearest.size());

//return nearPoints.nearest;



//update fpoints list

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

FPoint fp = (FPoint) fpoints.get(i);

NearPoint np = (NearPoint) nearPoints.nearest.get(i);

PVector npt = np.pos;



fp.setDestination(np.pos);

}



}

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

// sets

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

public void add(FPoint fpoint) {

fpoints.add(fpoint);

size = fpoints.size();

}

public void clear() {

fpoints.clear();

size = fpoints.size();

}



public void remove(int index) {

fpoints.remove(index);

size = fpoints.size();

}

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

// gets

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

public boolean running() {

return bRunning;

}

public FPoint getFPoint(int index) {

return (FPoint) fpoints.get(index);

}

}
thanks.

Ken

http://kenfrederick.blogspot.com/
http://cargocollective.com/kenfrederick/

mesh (delaunay) with hole

[1 Reply]
- 26-Dec-2010 01:39 PM
- Forum: Contributed Library Questions
i'm using the mesh library by lee byron http://leebyron.com/else/mesh/

(although i'm open to another mesh library, whether it be toxi's, hemesh, or whatever)

what i'm trying to do is build a mesh that has a hole in it. essentially i'm creating a series of points that form a circle (the outer edges of the mesh) then creating a shape in the middle (triangle) and then populating it with random points. however when i create the delanay mesh all of the points are connected.

so how do i create a mesh that only connects the points in the space between the middle shape (triangle) and the outer shape (circle). i don't want any lines or points to be in the middle? probably not a delanay mesh? or is it multiple delanay meshes?

any help/insight would be much appreciated.

here's some code (don't judge me... haha)
2. //-----------------------------------------------------------------------------
3. //libraries
4. //-----------------------------------------------------------------------------
5. import megamu.mesh.*;
7. //-----------------------------------------------------------------------------
8. Delaunay del;
9. float[][] delEdges;
11. PVector[] tri = new PVector[3]; //middle shape (hole)
12. ArrayList coord = new ArrayList(); //more flexible adding of points
13. float res;
14. int rand;
15. float rad;
17. void setup() {
18. size(400,400);
20. res = 36;
21. rand = 10;
22. rad = 100;
24. createPoints();
25. }
27. void draw() {
28. background(0);
29. noFill();
31. translate(width/2,height/2);
33. //------------------------------------
34. //facets
35. //------------------------------------
36. stroke(255,0,255);
37. beginShape(LINES);
38. //is there a way to use TRIANGLE_STRIP or QUAD_STRIP?
39. //maybe even extract faces?
40. for(int i=0; i<delEdges.length; i++) {
41. float x1 = delEdges[i][0];
42. float y1 = delEdges[i][1];
43. float x2 = delEdges[i][2];
44. float y2 = delEdges[i][3];
46. vertex( x1,y1 );
47. vertex( x2,y2 );
48. }
49. endShape(CLOSE);
51. //------------------------------------
52. //triangle
53. //------------------------------------
54. //just to see the triangle middle form
55. stroke(0,255,255);
56. triangle( tri[0].x, tri[0].y,
57. tri[1].x, tri[1].y,
58. tri[2].x, tri[2].y );
60. }
63. //-----------------------------------------------------------------------------
64. //methods
65. //-----------------------------------------------------------------------------
66. void createPoints() {
67. coord.clear();
69. //create triangle points
70. //keeps them at the front of mt coords array
71. //should the be seperate?
72. int index = 0;
73. for(int i=0; i<360; i+=360/tri.length) {
74. float x = cos( radians(i) ) * rad * 0.61;
75. float y = sin( radians(i) ) * rad * 0.61;
76. tri[index] = new PVector(x,y);
77. coord.add( tri[index].array() );
79. index++;
80. }
82. //create points for circle
83. for(int i=0; i<360/res; i++) {
84. float x = cos( radians(i*res) ) * rad;
85. float y = sin( radians(i*res) ) * rad;
86. coord.add( new float[]{x,y} );
87. }
89. //create the random points
90. //not sure how to exclude from the middle form
91. for(int i=0; i<rand; i++) {
92. float x = random( -cos( radians(i*res) ), cos( radians(i*res) ) ) * rad;
93. float y = random( -sin( radians(i*res) ), sin( radians(i*res) ) ) * rad;
94. coord.add( new float[]{x,y} );
95. }
97. del = new Delaunay( getFloatArray(coord) );
98. delEdges = del.getEdges();
99. }
101. float[][] getFloatArray(ArrayList a) {
102. float[][] floatArray = new float[a.size()][3];
104. for(int i=0; i<a.size(); i++) {
105. float[] temp = (float[]) a.get(i);
106. floatArray[i] = temp;
107. }
109. return floatArray;
110. }
112. //-----------------------------------------------------------------------------
113. //interactvitiy
114. //-----------------------------------------------------------------------------
115. void mousePressed() {
116. createPoints();
117. }
http://kenfrederick.blogspot.com/
http://cargocollective.com/kenfrederick/

points with equal distance (repulsion) from a line

[6 Replies]
- 30-Aug-2010 05:32 AM
- Forum: Programming Questions
pardon my geometry ignorance.

i've been racking my brain trying to remember how to do this, i found some helpful links

http://processing.org/discourse/yabb2/YaBB.pl?num=1276644884

http://www.intmath.com/Plane-analytic-geometry/Perpendicular-distance-point-line.php

but i just can't seem to implement them in the way i want.

what i'm doing is simply drawing a line on the screen and i want to maintain the same thickness i.e. the same distance (distX) of ptA and ptB from the line. currently when i draw the line from top to bottom it's the proper thickness, but when drawing left to right it's much thinner.

how can i maintain the proper relationship of ptA to ptB even when the orientation flips, i.e. horizontal to vertical? i know it has something to do with measuring the angle.

thanks

Ken

schhplttlr: electric beats (generative lights & music performance)

[0 Replies]
- 27-Jul-2010 10:03 AM
- Forum: Share your Work
for the past couple of months i've been working on a project called schhplttlr: electric beats with daniel kluge and eugen kern-emden presented by peer to space and in collaboration with the department of cultural affairs munich.

Using movements inspired from “Schuhplattler” (traditional Bavarian folk dance). The dancers generate beats and light via sensors. Musicians, media artists, dancers and choreographers experiment with these movements during a three-day long interdisciplinary workshop, in which the audience may freely participate.

The results were performed at the opening evening on July 15, 2010. This documentary film and photographs will be projected in MaximiliansForum from July 19, 2010 until September 5, 2010.

the actual performance you can see here: http://vimeo.com/13598389

and if you're interested in the process we've captured that as well:

danielkluge.com/XX2010/schhplttlr.htm

kenfrederick.blogspot.com/2010/07/schhplttlr.html

Ken

--

http://kenfrederick.blogspot.com/

http://cargocollective.com/kenfrederick/

«Prev
Next »