More than one attractor point.

Programming Questions

p3tr4s

More than one attractor point.

in Programming Questions • 10 months ago

Hello,

I am working on a script that is based on one point attraction.

First of all, the script has two classes "Electrons" and "Field".

For now, I managed to create two points by names charge[k] and charge2[k].

Then I bumped into the line, that tells
x, y, r, g, b, transparency, count, initial diameter, minChargediameter, maxChargediameter... the fields
---> THIS CONTROLS THE POINT LOCATION AND OTHER THINGS THAT EVENTUALLY CONTROLS THE ATTRACTION ---->VARIABLE MAGNITUDE.

vectors[i][j].update(charge[k].x+charge2[k].x, charge[k].y+charge2[k].x, charge[k].diameter, charge[k].minChargediameter, charge[k].maxChargediameter);

I thought I could multiple or do other mathematical operation with points' location in a grid of arrows. But
the result becomes just as using one point, but in a distorted way, let say... Ouch...

Anyway, if you do not have time to run the script, please at least say how two attractor points affect the grid?

The problem I have - I want to have more than one attractor point.
Is it possible to modify the script to do that?

The script only creates one array of arrows that is modified by only one point.
If you create let say 3, 5, 7 points. The script makes 3,5,7 separate grids of arrows. They all are not connected with each other.

I would like to create not a separate grids of arrows, but only one grid of arrows and their direction could be changed by multiple attracting points.

Best regards,
Petras Vestaras

int numCharges = 1;
Electrons[] charge = new Electrons[numCharges];
Electrons[] charge2 = new Electrons[numCharges];
int numVectorsX = 21;
int numVectorsY = 21;
int distance = 30;

Field[][] vectors = new Field[numVectorsX][numVectorsY];
float targetX = 300, targetY = 150, pol, fieldStrength, minDiameter, maxDiameter;
float theta = 0;
int magnitude;
float Fieldstrength;

void setup() {
size(600, 600);
smooth();
noStroke();
for (int k = 0; k < numCharges; k++) {
    //////////////////////////////////////////////////////////////////////////////////
     //x, y, r, g, b, transparency, count, initial diameter, minChargediameter, maxChargediameter... the fields
    charge[k] = new Electrons(100+(200*k), 100+(50*k),              0, 0, 0,                100, 1, 100,         20, 400);
    charge2[k] = new Electrons(400+(200*k), 100+(50*k),              0, 0, 0,                100, 1, 100,         20, 400);
    //////////////////////////////////////////////////////////////////////////////////
}
float maxdist = 400;
for (int i = 0; i<numVectorsX; i++) {
    for (int j = 0; j < numVectorsY; j++) {
      vectors[i][j] = new Field(i*distance, j*distance, magnitude, theta, maxdist);
    }
}
}

void draw() {
fill(255, 30);
rect(0, 0, 1000, 1000);
for (int k = 0; k<numCharges; k++) {
    charge[k].move();
    charge[k].display();
     charge2[k].move();
    charge2[k].display();
}
for (int k = 0; k<numCharges;k++) {
    for (int i=0; i<numVectorsX;i++) {
      for (int j=0; j<numVectorsY; j++) {
        vectors[i][j].plot();
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        vectors[i][j].update(charge[k].x+charge2[k].x, charge[k].y+charge2[k].x, charge[k].diameter, charge[k].minChargediameter, charge[k].maxChargediameter);
               ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     vectors[i][j].polarity(charge[k].r);
      }
    }
}
/*
   for (int k = 0; k<numCharges;k++) {
    for (int i=0; i<numVectorsX;i++) {
      for (int j=0; j<numVectorsY; j++) {
        vectors[i][j].plot();
        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        vectors[i][j].update(charge2[k].x, charge2[k].y, charge2[k].diameter, charge2[k].minChargediameter, charge2[k].maxChargediameter);
               ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        vectors[i][j].polarity(charge2[k].r);
      }
    }
}
*/
}

void mouseReleased() {
if (mouseButton == CENTER) {
    for (int k = 0; k<numCharges;k++) {
      charge[k].released();
    }
}
    if (mouseButton == CENTER) {
    for (int k = 0; k<numCharges;k++) {
      charge2[k].released();
    }
}
}
class Electrons {

float x, y, r, g, b, transparency, diameter, minChargediameter, maxChargediameter;
int count;
Electrons(float xpos, float ypos, float rpos, float gpos, float bpos, float trans, int countpos, float diameterpos, float minChargediameterpos, float maxChargediameterpos) {
    x = xpos;
    y = ypos;
    r = rpos;
    g = gpos;
    b = bpos;
    transparency = trans;
    count = countpos;
    diameter = diameterpos;
    minChargediameter = minChargediameterpos;
    maxChargediameter = maxChargediameterpos;
}

void move() {
    if (((dist(mouseX, mouseY, x, y))<(diameter/2))&&(mousePressed == true)) {//tests to see if mouse is on charge
      if (mouseButton == LEFT) {
        x = mouseX;
        y = mouseY;
      }
      else if (mouseButton == RIGHT) {//dragging mouse toward centre decreases size of charge
        if (((dist(mouseX, mouseY, x, y))-(dist(pmouseX, pmouseY, x, y)))>(0)) {
          if (diameter < maxChargediameter) {//prevents diameter getting too big, max diameter is 400
            diameter = diameter + 5; //increases size of diameter
            transparency += 0.5;
          }
        } //dragging mouse away from center increases size of charge
        else if (((dist(mouseX, mouseY, x, y))-(dist(pmouseX, pmouseY, x, y)))<(0)) {
          if (diameter > minChargediameter) {//prevents diameter getting too small and circle disappearing, min diameter is 20
            diameter = diameter - 5; // decreases size of diameter
            transparency -= 0.5;
          }
        }
      }
    }
}

void display() {
    fill(r, g, b, transparency);
    ellipse(x, y, diameter, diameter);
}
void released() {
    if (((dist(mouseX, mouseY, x, y))<(diameter/2))) {
      count = (count+1)%2;
      if (count==1) {
        r = 0;
        b = 255;
      }
      else if (count == 0) {

        r = 255;
        b = 0;
      }
    }
}
}
class Field {
float xField, yField, magnitude, theta, maxdist;
float vector;
int c, value, sign = 1;

Field(float xFieldpos, float yFieldpos, float magnitudepos, float thetapos, float maxdistpos) {
    xField = xFieldpos;
    yField = yFieldpos;
    magnitude = magnitudepos;
    theta = thetapos;
    maxdist = maxdistpos;
}

void plot() {
    float theta = atan((targetY-yField)/(targetX-xField));
    if (targetX<xField) {
      theta+=PI;
    }
    if (pol == 0) {
      theta+=PI;
    }
    //////////////////////////////////////////////////////////////
    float d = (sqrt(pow(targetY-yField, 2)+pow(targetX-xField, 2)));
    //////////////////////////////////////////////////////////////
    float maxFieldstrength, minFieldstrength = 0;
    float newVectorlengthmin = 10, newVectorlengthmax = 35;
    float minDiameter = 20, maxDiameter = 400;
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    maxFieldstrength = map(fieldStrength, minDiameter, maxDiameter, newVectorlengthmin, newVectorlengthmax);
    //////////////////////////////////////////////////////////////////////////////////////////////////////
    if (d>maxFieldstrength) {

      float magnitude = map(d, 0, maxdist, maxFieldstrength, minFieldstrength);
      //////////////////// d ir maxFieldstrength - apibreztas, maxdist - 400, minFieldstrength - 0

      float fieldTransparency = map(d, 0, maxdist, 205, -20);
      stroke(1, fieldTransparency);
      fill(0, 0, 0);
      pushMatrix();
      translate(xField, yField);
      rotate(theta);
      line(0, 0, magnitude, 0);
      popMatrix();
      noFill();
      noStroke();
    }
}

void update(float x, float y, float diameter, float minChargediameter, float maxChargediameter) {
    targetX = x;
    targetY = y;
    fieldStrength = diameter;
    minDiameter = minChargediameter;
    maxDiameter = maxChargediameter;
}
void polarity(float r) {
    pol = r;
}
}

Replies(8)

amnon.owed

Re: More than one attractor point.

10 months ago

Well personally I find this code way too messy and convoluted to adapt. This overcomplicated way of setting up the program makes it hard to see what's going on where. I wrote an example from scratch that uses an in my opinion clearer distinction between global variables, classes and mouse events. Also it uses PVector and java generics to shorten the code. See below. You can move Electrons with the mouse. Press a key to reset all the Electron charges.

Code Example

int gridDim = 25;
int numCharges = 4;
float maxStrengthPerCharge = 100/numCharges;
ArrayList <Vector> field = new ArrayList <Vector> ();
ArrayList <Electron> charges = new ArrayList <Electron> ();
PVector mouse = new PVector();
void setup() {
size(800, 800);
smooth();
strokeWeight(1.5);
int w = width/gridDim;
int h = height/gridDim;
for (int y=0; y<gridDim; y++) {
for (int x=0; x<gridDim; x++) {
field.add(new Vector((x+0.5)*w, (y+0.5)*h));
}
}
resetElectrons();
}
void draw() {
background(255);
mouse.set(mouseX, mouseY, 0);
for (Electron e : charges) {
e.update();
e.display();
}
for (Vector v : field) {
v.update();
v.display();
}
}
void keyPressed() {
resetElectrons();
}
void mousePressed() {
for (Electron e : charges) {
if(mouse.dist(e.pos) < e.charge*0.5) {
e.selected = true;
}
}
}
void mouseReleased() {
for (Electron e : charges) {
e.selected = false;
}
}
void resetElectrons() {
charges.clear();
for (int i=0; i<numCharges; i++) {
charges.add( new Electron(random(width), random(height), random(30, 100)) );
}
}
class Electron {
PVector pos;
float charge;
boolean selected;
Electron(float x, float y, float charge) {
pos = new PVector(x, y);
this.charge = charge;
}
void update() {
if (selected) { pos.set(mouseX, mouseY, 0); }
}
void display() {
pushMatrix();
translate(pos.x, pos.y);
noStroke();
fill(0,0,255);
ellipse(0, 0, charge, charge);
popMatrix();
}
}
class Vector {
PVector pos, dir;
Vector(float x, float y) {
pos = new PVector(x, y);
dir = new PVector();
}
void update() {
dir.set(0,0,0);
for (Electron e : charges) {
PVector currentDir = e.pos.get();
float magnitude = map(currentDir.dist(pos), 0, width, maxStrengthPerCharge, 0);
currentDir.sub(pos);
currentDir.normalize();
currentDir.mult(-magnitude);
dir.add(currentDir);
}
}
void display() {
pushMatrix();
translate(pos.x, pos.y);
stroke(0);
line(0, 0, dir.x, dir.y);
translate(dir.x, dir.y);
rotate(atan2(dir.y, dir.x));
triangle(3,0,0,-3,0,3);
popMatrix();
}
}

p3tr4s

Re: Re: More than one attractor point.

10 months ago

Wow your script is so neat and and short.

I read each line of it to analyse it:)
Would you be nice to answer a few questions about it?

1.How to set point locations and charge value manually, because they are at random positions at now. For example I would like to have 3 points. A - (100,100,50) B (300,300,30) C (500,500,90)
2. What does the line "this.charge = charge;" mean?
3. Does this line mean that processing measures distance between every attractor point and every grid point? Then the question, how width and maxStrengthPerChange are associated with each other?

float magnitude = map (currentDir.dist(pos), 0, width, maxStrengthPerChange, 0);

4. What is the method to draw lines between lines?

void display() {
    pushMatrix();
    translate(pos.x, pos.y);
    stroke(10);
    beginShape();
    vertex(dir.x, dir.y);
    endShape();
    translate(dir.x, dir.y);
    rotate(atan2(dir.y, dir.x));
    popMatrix();
    // What is the method to draw lines between lines?
}

GoToLoop

Re: Re: More than one attractor point.

10 months ago

I can only answer number 2:

this -> refers to the name of the class that this is in.

this.charge = charge; = Electron.charge = charge;

Generally, this is used to differentiate a local variable from a class variable w/ the same name.
Although it is also used for more tech stuff!

this.charge -> class variable
charge -> local variable

p3tr4s

Re: More than one attractor point.

10 months ago

It is so nice to hear from you amnom.owed:)

Now I am trying to identify what does what.
Your script is so short and does what I really wanted.

A lot of thanks:)

amnon.owed

Re: More than one attractor point.

10 months ago

Thanks.

To answer your questions:

1. Replace the resetElectrons() call on line 19 with the following lines:

charges.add( new Electron(100, 100, 50) );
charges.add( new Electron(300, 300, 30) );
charges.add( new Electron(500, 500, 90) );

2. The word this is special in java. It refers to the object / instance that the specific line of code is in. In the code example this refers to the Electron instance that is being created. So this.charge is the charge value from the Electron object / instance, while charge (without this) refers to the third parameter from the constructor: Electron(float x, float y, float charge). So the complete line "this.charge = charge" sets the object / instance Electron's charge value to the incoming value from the constructor. See this page for an explanation on OOP. As shown on the linked page, some people like to use temp or an _ underscore, but personally I like to use the exact same variable name and this to distinguish between the two.

3. To answer your question: yes you are in the right direction. That line is inside a Vector class and instance. That line is also inside a for loop that goes over each Electron. So what this function "currentDir.dist(pos)" does is measure the distance between this Vector instance and the Electron. But given the previous two points, it's basically the distance between each Electron and each Vector. With regard to the rest of the line, see the reference for map(). It takes the value (here: distance between Electron and Vector.) and remaps it from old value (0 to width) to new value (maxStrengthPerChange to 0). In words if the distance was 0, the magnitude is set to maxStrengthPerChange. If the distance was width, the magnitude is set to 0. And everything in between and beyond. So there is an inverse relation between distance and magnitude.

4. I don't know what you mean and your code only draws a single point.

p3tr4s

Re: More than one attractor point.

10 months ago

Question nr. 4:)

Let say, Now I have vector lines like in this picture ---> vector lines
But, if it is possible I would like to have ---> continuous lines

By continuous lines I image points a grid of points that are connected with neighbours, like a traingular or quadratic mesh.
For example point number x1 y1 is connected with x1 y2 , x1 y2 with x1 y3. :)

amnon.owed

Re: More than one attractor point.

10 months ago

Ok. See the adapted code below. Press g to toggle between two types of grid displays.

Adapted Code

int gridDim = 25;
int numCharges = 4;
float maxStrengthPerCharge = 100/numCharges;
ArrayList <Vector> field = new ArrayList <Vector> ();
ArrayList <Electron> charges = new ArrayList <Electron> ();
PVector mouse = new PVector();
boolean fullGrid;
void setup() {
size(800, 800);
smooth();
strokeWeight(1.5);
int w = width/gridDim;
int h = height/gridDim;
for (int y=0; y<gridDim; y++) {
for (int x=0; x<gridDim; x++) {
field.add(new Vector((x+0.5)*w, (y+0.5)*h));
}
}
resetElectrons();
}
void draw() {
background(255);
mouse.set(mouseX, mouseY, 0);
for (Electron e : charges) {
e.update();
e.display();
}
for (Vector v : field) {
v.update();
// display method removed (also from class)
}
noFill();
stroke(0);
for (int y=0; y<gridDim-1; y++) {
if (fullGrid) { beginShape(QUAD_STRIP); }
else { beginShape(LINES); }
for (int x=0; x<gridDim; x++) {
Vector vec1 = field.get(x+y*gridDim);
Vector vec2 = field.get(x+(y+1)*gridDim);
vertex(vec1.pos.x+vec1.dir.x, vec1.pos.y+vec1.dir.y);
vertex(vec2.pos.x+vec2.dir.x, vec2.pos.y+vec2.dir.y);
}
endShape();
}
}
void keyPressed() {
if (key == 'g') { fullGrid = !fullGrid; }
else { resetElectrons(); }
}
void mousePressed() {
for (Electron e : charges) {
if(mouse.dist(e.pos) < e.charge*0.5) {
e.selected = true;
}
}
}
void mouseReleased() {
for (Electron e : charges) {
e.selected = false;
}
}
void resetElectrons() {
charges.clear();
for (int i=0; i<numCharges; i++) {
charges.add( new Electron(random(width), random(height), random(30, 100)) );
}
}
class Electron {
PVector pos;
float charge;
boolean selected;
Electron(float x, float y, float charge) {
pos = new PVector(x, y);
this.charge = charge;
}
void update() {
if (selected) { pos.set(mouseX, mouseY, 0); }
}
void display() {
pushMatrix();
translate(pos.x, pos.y);
noStroke();
fill(0,0,255);
ellipse(0, 0, charge, charge);
popMatrix();
}
}
class Vector {
PVector pos, dir;
Vector(float x, float y) {
pos = new PVector(x, y);
dir = new PVector();
}
void update() {
dir.set(0,0,0);
for (Electron e : charges) {
PVector currentDir = e.pos.get();
float magnitude = map(currentDir.dist(pos), 0, width, maxStrengthPerCharge, 0);
currentDir.sub(pos);
currentDir.normalize();
currentDir.mult(-magnitude);
dir.add(currentDir);
}
}
}

p3tr4s

Re: Re: More than one attractor point.

10 months ago

Hi :)

I have a question about negative attraction with certain points.
According to the script below I have 3 points and they all are changing a grid of points in one dirrection.
Is it possible to have 1st point positive magnitude radius, 2nd - negative m.r., 3rd - positive m. r.
By magnitude, I mean this line:

float magnitude = map(currentDir.dist(pos), 0, width, maxStrengthPerCharge, 0);

The code:

int gridDim = 100;
int numCharges = 3;
float maxStrengthPerCharge = 100/numCharges;
ArrayList <Vector> field = new ArrayList <Vector> ();
ArrayList <Electron> charges = new ArrayList<Electron>();
PVector mouse = new PVector();

boolean fullGrid;
int value = 1;
int multi = 400;

void setup() {
size(800, 800);
smooth();
strokeWeight(0.5);
int w = width/gridDim;
int h = height/gridDim;
for (int y = 0; y<gridDim; y++) {
    for (int x = 0; x<gridDim; x++) {
      field.add(new Vector((x+0.5)*w, (y+0.5)*h));//ARRAY OF GRID POINTS
    }
}
resetElectrons();
}

void draw() {
background(255);
mouse.set(mouseY, mouseX, 0);

for (Electron e : charges) {
    e.display();
}
for (Vector v : field) {
    v.update();
}

value = ((frameCount%201<101)?1:-1)*(frameCount%100);///////////FOR MOVING POINTS
if (value!=0) {/////////////////////////////////////////////////FOR MOVING POINTS
    if (value < 0) { /////////////////////////////////////////////FOR MOVING POINTS
      value = 100 + value;////////////////////////////////////////FOR MOVING POINTS
    }/////////////////////////////////////////////////////////////FOR MOVING POINTS

    for (int y = 0; y<gridDim-1; y++) {
      noFill();
      beginShape(LINES);//QUAD_STRIP FOR MESH
      for (int x = 0; x<gridDim; x++) {
        stroke(1);
        Vector vec1 = field.get(x+y*gridDim);
        Vector vec2 = field.get(x+(y+1)*gridDim);

        vertex(vec1.pos.x+(vec1.dir.x)*value/multi, vec1.pos.y+(vec1.dir.y)*value/multi);
        vertex(vec2.pos.x+(vec2.dir.x)*value/multi, vec2.pos.y+(vec2.dir.y)*value/multi);
       //ellipse(vec2.pos.x+(vec2.dir.x)*value/multi, vec2.pos.y+(vec2.dir.y)*value/multi, 2, 2);
        //println((vec1.dir.x)*value/multi);

      }
    }
    endShape();
}
}

void resetElectrons() {
charges.clear();
for (int i = 0; i<numCharges; i++) {
    charges.add(new Electron(400, 400, 20));
    charges.add(new Electron(200, 300, 20));
   charges.add(new Electron(500, 200, 20));
}
}
class Electron {
PVector pos;
float charge;

Electron(float x, float y, float charge) {
    pos = new PVector (x, y);
    this.charge=charge;
}
void display() {
    pushMatrix();
    translate(pos.x, pos.y);
    noStroke();
    fill(0);
    ellipse(0, 0, charge, charge);
    popMatrix();
}
}
class Vector {
PVector pos, dir;

Vector(float x, float y) {
    pos = new PVector(x, y);
    dir = new PVector();
}

void update() {
    dir.set(0, 0, 0);
    for (Electron e : charges) {
      PVector currentDir = e.pos.get();
      float magnitude = map(currentDir.dist(pos), 0, width, maxStrengthPerCharge, 0);
/////////////////////////////////////////////// MAGNITUDE RADIUS
      float positivemagnitude = abs(magnitude);
      if (positivemagnitude<28) {
        positivemagnitude=0;
      }
    if (positivemagnitude>69) {
      positivemagnitude=69;
    }
/////////////////////////////////////////////// MAGNITUDE RADIUS
      currentDir.sub(pos);
      currentDir.normalize();
      currentDir.mult(-positivemagnitude);
      dir.add(currentDir);
    }
}
}

Yesterday I was playing with your script a lot of hours..., as a result I made the video: VIDEO
I just added movement according to frameCount and a little bit of colors and music:)
I will rerender frames to add your name:)