Loading...
Logo
Processing Forum
Programming Questions
clankill3r
clankill3r

connect end to start with interpolation

in Programming Questions  •  3 months ago  
I would like to connect the start to the end:

There is a center ellipse which is a bit smaller. By me it goes the wrong way around when i try to connect the first to the last.

check void advancedDraw2, it happens there.
For now i just return, disable that.

can someone help?

Copy code
  1. float centerX, centerY;

  3. ArrayList<Tangible> tangibles = new ArrayList<Tangible>();

  5. void setup() {
  6.   size(700, 700); 
  7.   smooth();

  9.   centerX = width/2;
  10.   centerY = height/2;
  11. }

  13. // . . . . . . . . . . . . . . . . . . .


  16. void draw() {
  17.   background(0);

  19.   fill(255);
  20.   noStroke();
  21.   ellipse(centerX, centerY, 10, 10);

  23.   for (int i = 0; i < tangibles.size(); i++) {
  24.     Tangible t = tangibles.get(i);
  25.     ellipse(t.centerX, t.centerY, 15, 15);
  26.   }

  28.  // simpleDraw();
  29.  // advancedDraw();
  30.     advancedDraw2();

  32. }

  34. // . . . . . . . . . . . . . . . . . . .

  36. void advancedDraw() {
  37.   stroke(255);
  38.   if (tangibles.size() >= 2) {
  39.     Tangible t1 = null;
  40.     Tangible t2 = null;
  41.     for (int i = 0; i < tangibles.size()-1; i++) {
  42.       t1 = tangibles.get(i);
  43.       t2 = tangibles.get(i+1);
  44.       //line(t1.centerX, t1.centerY, t2.centerX, t2.centerY);
  45.       // radius
  46.       float r1 = dist(t1.centerX, t1.centerY, centerX, centerY);
  47.       float r2 = dist(t2.centerX, t2.centerY, centerX, centerY);
  48.       // steps can be based on difference in angle and radius
  49.       // for now use a fixed value
  50.       //float angleDifference = t2.angle - t1.angle;
  51.       
  52.       int steps = (int) max(r1, r2);

  54.       
  55.       for(int s = 0; s < steps; s++) {
  56.         float t = norm(s, 0, steps);
  57.         float r = map(t, 0, 1, r1, r2);
  58.         float a = map(t, 0, 1, t1.angle, t2.angle);
  59.         float x = cos(a) * r;
  60.         float y = sin(a) * r;
  61.         ellipse(centerX+x, centerY+y, 3, 3);
  62.         //println(y);
  63.            
  64.       }
  65.       
  66.     }
  67.     // connect first to last
  68.     t1 = tangibles.get(0);
  69.     //line(t1.centerX, t1.centerY, t2.centerX, t2.centerY);
  70.   }
  71. }


  74. // . . . . . . . . . . . . . . . . . . .


  77. void advancedDraw2() {
  78.   stroke(255, 200);
  79.   println("----");
  80.   if (tangibles.size() >= 2) {
  81.     Tangible t1 = null;
  82.     Tangible t2 = null;
  83.     for (int i = 0; i < tangibles.size(); i++) {
  84.       
  85.       if(i == tangibles.size()-1) {
  86.        println("help!"); 
  87.        t1 = tangibles.get(0);
  88.        t2 = tangibles.get(i);
  89.        // disable for now
  90.        return;
  91.       }
  92.       else {
  93.         t1 = tangibles.get(i);
  94.         t2 = tangibles.get(i+1);
  95.       }


  98.       // radius
  99.       float r1 = dist(t1.centerX, t1.centerY, centerX, centerY);
  100.       float r2 = dist(t2.centerX, t2.centerY, centerX, centerY);
  101.       
  102.       float rDifference = r2 - r1;
  103.       
  104.       float aDifference = t2.angle - t1.angle;

  106.       // the larger the radius the more steps we use
  107.       int steps = (int) max(r1, r2);
  108.       // steps /= 2;
  109.       
  110.       //println("steps: "+steps);
  111.       
  112.       // previous
  113.       float px = cos(t1.angle) * r1;
  114.       float py = sin(t1.angle) * r1;
  115.       
  116.       
  117.       for(int s = 0; s <= steps; s++) {
  118.         float t = norm(s, 0, steps);
  119.         //float r = map(t, 0, 1, r1, r2);
  120.         float r = r1 + rDifference * t;
  121.         //float a = map(t, 0, 1, t1.angle, t2.angle);
  122.         float a = t1.angle + aDifference * t;
  123.         float x = cos(a) * r;
  124.         float y = sin(a) * r;

  126.         line(px + centerX, py + centerY, x + centerX, y + centerY);
  127.         px = x;
  128.         py = y;           
  129.       }
  130.       
  131.     }
  132.   }
  133. }


  136. // . . . . . . . . . . . . . . . . . . .


  139. void simpleDraw() {
  140.   stroke(255);
  141.   if (tangibles.size() >= 2) {
  142.     Tangible t1 = null;
  143.     Tangible t2 = null;
  144.     for (int i = 0; i < tangibles.size()-1; i++) {
  145.       t1 = tangibles.get(i);
  146.       t2 = tangibles.get(i+1);
  147.       line(t1.centerX, t1.centerY, t2.centerX, t2.centerY);
  148.     }
  149.     // connect first to last
  150.     t1 = tangibles.get(0);
  151.     line(t1.centerX, t1.centerY, t2.centerX, t2.centerY);
  152.   }
  153. }

  155. // . . . . . . . . . . . . . . . . . . .


  158. boolean mouseDragged;

  160. void mouseDragged() {

  162.   mouseDragged = true;

  164.   Tangible closest = closestTangible(mouseX, mouseY);
  165.   if (closest != null) {
  166.     float d = dist(mouseX, mouseY, closest.centerX, closest.centerY);
  167.     if (d < 20) {
  168.       closest.centerX = mouseX;
  169.       closest.centerY = mouseY;
  170.       closest.calculateAngle(centerX, centerY);
  171.       sortTangibles();
  172.     }
  173.   }
  174. }


  177. // . . . . . . . . . . . . . . . . . . .


  180. void mouseReleased() {

  182.   if (mouseDragged) {
  183.     mouseDragged = false;
  184.     return;
  185.   }

  187.   Tangible closest = closestTangible(mouseX, mouseY);

  189.   if (closest == null) {
  190.     Tangible t = new Tangible(mouseX, mouseY);
  191.     t.calculateAngle(centerX, centerY);
  192.     tangibles.add(t);
  193.   }
  194.   else {
  195.     float d = dist(mouseX, mouseY, closest.centerX, closest.centerY);
  196.     if (d < 20) {
  197.       tangibles.remove(closest);
  198.     }  
  199.     else {
  200.       Tangible t = new Tangible(mouseX, mouseY);
  201.       t.calculateAngle(centerX, centerY);
  202.       tangibles.add(t);
  203.     }
  204.   }

  206.   sortTangibles();
  207. }


  210. // . . . . . . . . . . . . . . . . . . .

  212. void sortTangibles() {
  213.   Collections.sort(tangibles, new TangibleComparator());
  214.   println();
  215.   for (int i = 0; i < tangibles.size(); i++) {
  216.     Tangible t = tangibles.get(i);
  217.     println(t.angle);
  218.   }
  219. }

  221. // . . . . . . . . . . . . . . . . . . .



  225. Tangible closestTangible(float x, float y) {
  226.   Tangible closest = null;
  227.   float closestDist = MAX_FLOAT;

  229.   for (int i = 0; i < tangibles.size(); i++) {
  230.     Tangible t = tangibles.get(i);
  231.     float d = dist(t.centerX, t.centerY, x, y);
  232.     if (d < closestDist) {
  233.       closestDist = d;
  234.       closest = t;
  235.     }
  236.   }

  238.   return closest;
  239. }

  241. // . . . . . . . . . . . . . . . . . . .

  243. class Tangible {

  245.   float centerX, centerY;
  246.   float angle;

  248.   Tangible(float centerX, float centerY) {
  249.     this.centerX = centerX;
  250.     this.centerY = centerY;
  251.   }

  253.   void calculateAngle(float x, float y) {
  254.     angle = atan2(centerY -y, centerX-x);
  255.     //angle = atan2(y-centerY, x-centerX);
  256.     if (angle < 0) angle += TWO_PI;
  257.   }
  258. }

  260. // . . . . . . . . . . . . . . . . . . .

  262. class TangibleComparator implements Comparator<Tangible> {

  264.   int compare(Tangible t1, Tangible t2) {
  265.     if (t1.angle > t2.angle) {
  266.       return 1;
  267.     }  
  268.     else if (t1.angle > t2.angle) {
  269.       return -1;
  270.     }
  271.     return 0;
  272.   }
  273. }

Replies(4)

Mushussu
Mushussu

Re: connect end to start with interpolation

3 months ago
I have a solution, try this :

Copy code
  2. void advancedDraw2() {
  3.   stroke(255, 200);
  4.   println("----");
  5.   if (tangibles.size() >= 2) {
  6.     Tangible t1 = null;
  7.     Tangible t2 = null;
  8.     for (int i = 0; i < tangibles.size(); i++) {
  9.       float aDifference;
  10.       if (i == tangibles.size()-1) {
  11.         println("help!"); 
  12.         t1 = tangibles.get(0);
  13.         t2 = tangibles.get(i);

  15.         aDifference = t2.angle - t1.angle - TWO_PI;
  16.       }
  17.       else {
  18.         t1 = tangibles.get(i);
  19.         t2 = tangibles.get(i+1);
  20.         aDifference = t2.angle - t1.angle;
  21.       }

  23.       // radius
  24.       float r1 = dist(t1.centerX, t1.centerY, centerX, centerY);
  25.       float r2 = dist(t2.centerX, t2.centerY, centerX, centerY);

  27.       float rDifference = r2 - r1;

  29.       // the larger the radius the more steps we use
  30.       int steps = (int) max(r1, r2);
  31.       // steps /= 2;

  33.       //println("steps: "+steps);

  35.       // previous
  36.       float px = cos(t1.angle) * r1;
  37.       float py = sin(t1.angle) * r1;


  40.       for (int s = 0; s <= steps; s++) {
  41.         float t = norm(s, 0, steps);
  42.         //float r = map(t, 0, 1, r1, r2);
  43.         float r = r1 + rDifference * t;
  44.         //float a = map(t, 0, 1, t1.angle, t2.angle);
  45.         float a = t1.angle + aDifference * t;
  46.         float x = cos(a) * r;
  47.         float y = sin(a) * r;

  49.         line(px + centerX, py + centerY, x + centerX, y + centerY);
  50.         px = x;
  51.         py = y;
  52.       }
  53.     }
  54.   }
  55. }
clankill3r
clankill3r

Re: connect end to start with interpolation

3 months ago
thank you so much!
clankill3r
clankill3r

Re: connect end to start with interpolation

3 months ago
I continued on the code and i have a problem in a simular fashion.
I tried multiple things inspired from the solution above but it seems a bit more tricky now.
Run the code and you will get what i mean.

here a image:

Copy code

    Copy code
    2. float centerX, centerY;

    4. ArrayList<Tangible> tangibles = new ArrayList<Tangible>();

    6. void setup() {
    7.   size(700, 700); 
    8.   smooth();
    9.   frameRate(60);

    11.   centerX = width/2;
    12.   centerY = height/2;
    13. }

    15. // . . . . . . . . . . . . . . . . . . .


    18. void draw() {
    19.   background(0);

    21.   fill(255);
    22.   noStroke();
    23.   ellipse(centerX, centerY, 10, 10);

    25.   for (int i = 0; i < tangibles.size(); i++) {
    26.     Tangible t = tangibles.get(i);
    27.     ellipse(t.centerX, t.centerY, 15, 15);
    28.   }

    30.   synthLineDraw();

    32.   float a = atan2(mouseY-centerY, mouseX - centerX);
    33.   if (a < 0) a += TWO_PI;
    34.   //println(a);
    35.   pushMatrix();
    36.   translate(centerX, centerY);
    37.   rotate(a);
    38.   line(200, 0, 0, 0);
    39.   popMatrix();

    41.   Tangible previous = previousTangibleFromAngle(a);
    42.   Tangible next = nextTangibleFromAngle(a);


    45.   if (previous != null) {
    46.     stroke(255, 0, 0);
    47.     noFill();
    48.     ellipse(previous.centerX, previous.centerY, 25, 25);

    50.     stroke(0, 255, 0);
    51.     noFill();
    52.     ellipse(next.centerX, next.centerY, 25, 25);

    54.     float t = norm(a, previous.angle, next.angle);

    56.     // radius
    57.     float r1, r2;
    58.     float rDifference;
    59.     
    60.     if(previous.angle < next.angle) {
    61.      r1 = dist(previous.centerX, previous.centerY, centerX, centerY);
    62.      r2 = dist(next.centerX, next.centerY, centerX, centerY);
    63.      rDifference = r2 - r1;
    64.     }
    65.     else {
    66.      r2 = dist(previous.centerX, previous.centerY, centerX, centerY);
    67.      r1 = dist(next.centerX, next.centerY, centerX, centerY);
    68.      rDifference = r2 - r1 - TWO_PI;
    69.     }
    70.     
    71.     
    72.     float r = r1 + rDifference * t;

    74.     pushMatrix();
    75.     translate(centerX, centerY);
    76.     rotate(a);
    77.     ellipse(r, 0, 10, 10);
    78.     popMatrix();
    79.   }




    84.   fill(255);
    85.   text(frameRate, 50, 50);
    86. }

    88. // . . . . . . . . . . . . . . . . . . .

    90. // assumes tangibles are sorted
    91. float interpolatedTangibleRadius(float a, Tangible t1, Tangible t2) {
    92.   return -1;
    93. }

    95. // . . . . . . . . . . . . . . . . . . .

    97. // assumes tangibles are sorted
    98. Tangible previousTangibleFromAngle(float a) {
    99.   if (tangibles.size() > 0) {
    100.     Tangible t = tangibles.get(0);
    101.     if (a < t.angle) {
    102.       // last one in list
    103.       return  tangibles.get(tangibles.size()-1);
    104.     }
    105.     else {

    107.       int index = tangibles.size()-1;

    109.       do {
    110.         t = tangibles.get(index);
    111.         index--;
    112.       }
    113.       while (a < t.angle);

    115.       return t;
    116.     }
    117.   }
    118.   return null;
    119. }


    122. // assumes tangibles are sorted
    123. Tangible nextTangibleFromAngle(float a) {
    124.   if (tangibles.size() > 0) {
    125.     Tangible t = tangibles.get(tangibles.size()-1);
    126.     if (a > t.angle) {
    127.       // last one in list
    128.       return  tangibles.get(0);
    129.     }
    130.     else {

    132.       int index = 0;

    134.       do {
    135.         t = tangibles.get(index);
    136.         index++;
    137.       }
    138.       while (a > t.angle);

    140.       return t;
    141.     }
    142.   }
    143.   return null;
    144. }



    148. // . . . . . . . . . . . . . . . . . . .



    152. void synthLineDraw() {
    153.   stroke(255, 200);

    155.   if (tangibles.size() >= 2) {
    156.     Tangible t1 = null;
    157.     Tangible t2 = null;
    158.     for (int i = 0; i < tangibles.size(); i++) {
    159.       float aDifference;
    160.       if (i == tangibles.size()-1) {
    161.         t1 = tangibles.get(0);
    162.         t2 = tangibles.get(i);

    164.         aDifference = t2.angle - t1.angle - TWO_PI;
    165.       }
    166.       else {
    167.         t1 = tangibles.get(i);
    168.         t2 = tangibles.get(i+1);
    169.         aDifference = t2.angle - t1.angle;
    170.       }

    172.       // radius
    173.       float r1 = dist(t1.centerX, t1.centerY, centerX, centerY);
    174.       float r2 = dist(t2.centerX, t2.centerY, centerX, centerY);

    176.       float rDifference = r2 - r1;

    178.       // the larger the radius the more steps we use
    179.       int steps = (int) max(r1, r2);
    180.       // steps /= 2;

    182.       //println("steps: "+steps);

    184.       // previous
    185.       float px = cos(t1.angle) * r1;
    186.       float py = sin(t1.angle) * r1;


    189.       for (int s = 0; s <= steps; s++) {
    190.         float t = norm(s, 0, steps);
    191.         //float r = map(t, 0, 1, r1, r2);
    192.         float r = r1 + rDifference * t;
    193.         //float a = map(t, 0, 1, t1.angle, t2.angle);
    194.         float a = t1.angle + aDifference * t;
    195.         float x = cos(a) * r;
    196.         float y = sin(a) * r;

    198.         line(px + centerX, py + centerY, x + centerX, y + centerY);
    199.         px = x;
    200.         py = y;
    201.       }
    202.     }
    203.   }
    204. }




    209. boolean mouseDragged;

    211. void mouseDragged() {

    213.   mouseDragged = true;

    215.   Tangible closest = closestTangible(mouseX, mouseY);
    216.   if (closest != null) {
    217.     float d = dist(mouseX, mouseY, closest.centerX, closest.centerY);
    218.     if (d < 40) {
    219.       closest.centerX = mouseX;
    220.       closest.centerY = mouseY;
    221.       closest.calculateAngle(centerX, centerY);
    222.       sortTangibles();
    223.     }
    224.   }
    225. }


    228. // . . . . . . . . . . . . . . . . . . .


    231. void mouseReleased() {

    233.   if (mouseDragged) {
    234.     mouseDragged = false;
    235.     return;
    236.   }

    238.   Tangible closest = closestTangible(mouseX, mouseY);

    240.   if (closest == null) {
    241.     Tangible t = new Tangible(mouseX, mouseY);
    242.     t.calculateAngle(centerX, centerY);
    243.     tangibles.add(t);
    244.   }
    245.   else {
    246.     float d = dist(mouseX, mouseY, closest.centerX, closest.centerY);
    247.     if (d < 20) {
    248.       tangibles.remove(closest);
    249.     }  
    250.     else {
    251.       Tangible t = new Tangible(mouseX, mouseY);
    252.       t.calculateAngle(centerX, centerY);
    253.       tangibles.add(t);
    254.     }
    255.   }

    257.   sortTangibles();
    258. }


    261. // . . . . . . . . . . . . . . . . . . .

    263. void sortTangibles() {
    264.   Collections.sort(tangibles, new TangibleComparator());
    265.   println();
    266.   for (int i = 0; i < tangibles.size(); i++) {
    267.     Tangible t = tangibles.get(i);
    268.     println(t.angle);
    269.   }
    270. }

    272. // . . . . . . . . . . . . . . . . . . .



    276. Tangible closestTangible(float x, float y) {
    277.   Tangible closest = null;
    278.   float closestDist = MAX_FLOAT;

    280.   for (int i = 0; i < tangibles.size(); i++) {
    281.     Tangible t = tangibles.get(i);
    282.     float d = dist(t.centerX, t.centerY, x, y);
    283.     if (d < closestDist) {
    284.       closestDist = d;
    285.       closest = t;
    286.     }
    287.   }

    289.   return closest;
    290. }

    292. // . . . . . . . . . . . . . . . . . . .

    294. class Tangible {

    296.   float centerX, centerY;
    297.   float angle;

    299.   Tangible(float centerX, float centerY) {
    300.     this.centerX = centerX;
    301.     this.centerY = centerY;
    302.   }

    304.   void calculateAngle(float x, float y) {
    305.     angle = atan2(centerY -y, centerX-x);
    306.     //angle = atan2(y-centerY, x-centerX);
    307.     if (angle < 0) angle += TWO_PI;
    308.   }
    309. }

    311. // . . . . . . . . . . . . . . . . . . .

    313. class TangibleComparator implements Comparator<Tangible> {

    315.   int compare(Tangible t1, Tangible t2) {
    316.     if (t1.angle > t2.angle) {
    317.       return 1;
    318.     }  
    319.     else if (t1.angle > t2.angle) {
    320.       return -1;
    321.     }
    322.     return 0;
    323.   }
    324. }
    clankill3r
    clankill3r

    Re: connect end to start with interpolation

    3 months ago
    Here's my solution. It feels a bit long but it works.
    I just rotate till the previous one is at TWO_PI and then i make 0 of it.

    Copy code
    1.      if(previous.angle < next.angle) {
    2.        t = norm(a, previous.angle, next.angle);
    3.      }
    4.      else {
    5.        float angleTillTwoPi = TWO_PI - previous.angle;
    6.        float pa = 0;
    7.        float na = next.angle + angleTillTwoPi;
    8.        float a2;
    9.       if(a >=  previous.angle) {
    10.         a2 = a - previous.angle;
    11.       }
    12.       else {
    13.        a2 = a + angleTillTwoPi; 
    14.       }
    15.       t = norm(a2, pa, na);
    16.      }
    Top Reply

    Statistics

    • 4 Replies
    • 375  Views
    • 0 Followers

    Tags

    No tags available for this topic.

    Actions

    Related Posts