Hello,
I need a program that gives me the possibility to set some points (3 to a 100 points) and make a spline curve out of it.
After that it should run along the spline and give me a circle that goes right through the spline point.
I already wrote some rough code with a bezier curve and the bezierPoint() function, but I need those points for a spline curve. 

Here is the code for the circle running along a bezier:
and here is what I want to have instead of the bezier curve:

1. size(500, 500);
   
   int[ ] coords = {
     40, 40, 80, 60, 100, 100, 60, 120, 50, 150, 200, 200,200,290,340,100
   };
   
   background(255);
   smooth();
   
   noFill();
   stroke(0);
   beginShape();
   curveVertex(0, 1); // the first control point
   for (int i = 0; i < coords.length ; i+=2) curveVertex(coords[i], coords[i+1]); // is also the start point of curve 
   curveVertex(coords.length-2, coords.length-1); // is also the last control point
   endShape();
   
   fill(255, 0, 0);
   noStroke();
   for (int i = 0; i < coords.length; i += 2) ellipse(coords[i], coords[i + 1], 3, 3);
   
   

I searched the Internet but did not find something that helped me.
It would be really great if someone could tell me how to change the bezier to a spline curve.

Florian

Hello,
I need to disable the zoom by right click function inside peasycam.
sadly I didn't find a way to do it...
I want something like that:

1.   cam = new PeasyCam(this,BodyPos.x,BodyPos.y,BodyPos.z,1000);
     cam.setMinimumDistance(200);
     cam.setMaximumDistance(5000);
     //cam.disable(right-drag);  // something like that
   

I found something inside the reference but did not understand that enough to use it.

1. setMouseControlled

   @Deprecated public void setMouseControlled(boolean isMouseControlled)

   Deprecated.  use setActive(boolean)

   Turn on or off default mouse-handling behavior:

   left-drag	rotate camera around look-at point
   center-drag	pan camera (change look-at point)
   right-drag	zoom
   wheel	zoom

   Parameters:

   isMouseControlled -

Can someone please help me?
Thank you very much!
Florian

Hey,
I am working on an robot and the comunication works kind of well.
Sending data to an Arduino works pretty perfect but getting data is an other thing...

The whole calculation is beeing done by the pc and than send to the robot.
sensor data is beeing send to processing vie serial.

I use the callback method for comunication:
processing says: "S"
arduino sends: "45S" back.


so far so good. The probleme is that the arduino gets much faster the request and sends the information than processing can read it, because it does quite a lot simultaniously.
I used a "delay" every 200ms(not the delay(); funktion) to cut the data a little down but that didn't work that well either.
I used the port.clear(); to clean the buffer. That worked well fot the one sensor but I lost the whole other sensory data....
I can not put the port.write("S"); into the     if ( port.available() >= 2) { than the dataflow would possible be just right but it will never be called...

someone an idea for me??
thank you :)
Florian



my Code looks something like that: (I won't post it because it is longer than 750 lines)

1. int IR,Voltage;Ampere;
2. 
   
3. void draw(){
4. 
   
5. text(sensor data);
6. funktion_That_Needs_Sensordata (sensor data);
7. Sensors();
8. big_Calculation_Stuff();
   
9. }
10. 
    
11. void Sensors(){
12.    
13.     port.write("S");
14.    
15.     if ( port.available() >= 2) {
16.         int ch = port.read();
17.         if ( ch >= '0' && ch <= '9') {v = v *10 + ch - '0';}
18.         else{ 
19.            switch(ch){
20.              case 'I': IR = v;   break;
21.              case 'V': Voltage = v/10.0;   break;
22.              case 'A': Ampere = v/10.0; break;
23.            }
24.            v = 0;
25.            //port.clear();
    
26.         
27.         }
28.     }
29. }

Hello,
I am writing an inverse kinematik program and I works perfectly fine...exept for the fact that I want to send the information calculated to my spiderrobot (Arduino). As soon I enable the function that is sending the data over serial to the Arduino it starts to run really chunky. I now have extracted the core of evil. the "port.write()" function itself.
even when I put a single number into that function and run the code everithing is messed up.
I allready wrote into the Aduino forum  >>HERE<<  but I know realized that it is more likely a Processing subject.
I posted the Processing code at the end of the first page there.  You don't need an Arduino to try it out.
what is the reason why the "port.write" is slowing everything down so much and is there a way so fix that?

best regards,
Florian


Here is the Processing code and I maked the part that is slowing everything down (pretty much at the end of the code)

SendLeg(leg, Deg);   /////////// slows down the programm immensly!!!

1. import processing.opengl.*;
   import processing.serial.*;       
   
   Serial port;
   
   
   
   float hx;
   float hy;
   float hz;
   
   float ex;
   float ey;
   float ez;
   
   
   
   
   float Bxz;
   float bxz;
   float Bleg;
   float B;                                    //B: length of imaginary line
   float q1;                                   //q1: angle between X-axis and imaginary line
   float q2;                                   //q2: interior angle between imaginary line and link l1
   float Qh;                                   //Qh; angle of of the hip on the ground plain
   float Q1rad;
   float Q1deg;                                //Q1: angle between x-axis and "l1"
   float Q2rad;                                   //Q2: angle between "l1" and "l2"
   float Q2deg;
   static long l1 = 130;                       //l1: length of the upper leg in mm
   static long l2 = 180;                        //l2: length of the lower leg in mm
   static long hL = 60;                        // length between inner hip and outer hip
   float Xpos;                                  //Xpos: relative X-position out of Xhip and Xfoot where the leg should move to
   float Ypos;                                  //Ypos: relative Y-position out of Yhip and Yfoot where the leg should move to   
   float Xfoot;
   float Yfoot;
   float Zfoot;
   float Xhip;                                  //Xpos: relative X-position out of Xhip and Xfoot where the leg should move to
   float Yhip; 
   
   int Stepp = 5;         // beide sind für die automatische begegung zuständig
   int Koord = 0;
   
    
    
   float steppLength = 50;
   float steppHight = 50;
   
   void setup(){
   size(screen.width, screen.height);
   
     println(Serial.list()); // List COM-ports
     port = new Serial(this, Serial.list()[2], 115200);
   
   }
   
   void draw(){
   
    
    
     background(255);
   
   
   Zfoot = mouseX-(width/2);
   
     if (Zfoot <= -150){Zfoot = -150;}
     if (Zfoot >=  150){Zfoot =  150;}
   
   Xfoot =  120;
   
   
   
   /*____________________________________________________________________________
   
     Koord = Koord + Stepp;                             // einfache schleife
     if (Koord == 20 || Koord == -90) {
        Stepp = -Stepp ;
     }
   Yfoot = Koord ;
   
   /____________________________________________________________________________________________
   */
   Yfoot = (height/2)-mouseY; //(90*sqrt((150*150)-(Zfoot*Zfoot))/150);
   
     if (Yfoot <= -100){Yfoot = -100;}
     if (Yfoot >=  20){Yfoot =  20;}
   
   
     KoordinatenSysteme();
    
   
   
   
   
     DrawLeg(0,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(1,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(2,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(3,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(4,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(5,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(6,0,60,Xfoot,Yfoot,Zfoot);
     DrawLeg(7,0,60,Xfoot,Yfoot,Zfoot);
   
   
    
   
   }
   
   
   
   
   //---------------------------------------------------------------------------------------------------------------------------------
   //--------------------------------------------------------|  Begin XZ koordinatesystem        |------------------------------------
   
   
   void KoordinatenSysteme(){
   
   
     
      stroke(0,0,255,30);
      strokeWeight(4);
   
   
   
   int gapH = height/100;
   int gapW = width/100;
   
    int[] Height = {height*1/4,height*2/4,height*3/4,height*4/4};
   int[] Width  = {width*1/4,width*2/4,width*3/4,width*4/4};
   
   //koordinaten system nullpunkten
   PVector Zero11 = new PVector(Width[0]/2,Height[0]);
   PVector Zero12 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero21 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero22 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero31 = new PVector(Width[0]/2,Height[1]);
   PVector Zero32 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero41 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero42 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero51 = new PVector(Width[0]/2,Height[2]);
   PVector Zero52 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero61 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero62 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero71 = new PVector(Width[0]/2,Height[3]);
   PVector Zero72 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[3]);
   PVector Zero81 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[3]);
   PVector Zero82 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[3]);
   
   //Quadranten einteilung
    
     line(0,Height[0],width,Height[0]);  //horizontal
     line(0,Height[1],width,Height[1]);  //horizontal
     line(0,Height[2],width,Height[2]);  //horizontal
    
     line(Width[0],0,Width[0],height);  //vertical
     line(Width[1],0,Width[1],height);  //vertical
     line(Width[2],0,Width[2],height);  //vertical
   
    
   
   
     //Koordinatensysteme
   
      stroke(0);
      strokeWeight(2);
     
      //Horizontal
    
     line(0+gapW,Height[0],Width[0]-gapW,Height[0]);
     line(Width[0]+gapW,Height[0],Width[1]-gapW,Height[0]);
     line(Width[1]+gapW,Height[0],Width[2]-gapW,Height[0]);
     line(Width[2]+gapW,Height[0],Width[3]-gapW,Height[0]);
    
     line(0+gapW,Height[1],Width[0]-gapW,Height[1]);
     line(Width[0]+gapW,Height[1],Width[1]-gapW,Height[1]);
     line(Width[1]+gapW,Height[1],Width[2]-gapW,Height[1]);
     line(Width[2]+gapW,Height[1],Width[3]-gapW,Height[1]);
    
     line(0+gapW,Height[2],Width[0]-gapW,Height[2]);
     line(Width[0]+gapW,Height[2],Width[1]-gapW,Height[2]);
     line(Width[1]+gapW,Height[2],Width[2]-gapW,Height[2]);
     line(Width[2]+gapW,Height[2],Width[3]-gapW,Height[2]);
    
       line(0+gapW,Height[3],Width[0]-gapW,Height[3]);
     line(Width[0]+gapW,Height[3],Width[1]-gapW,Height[3]);
     line(Width[1]+gapW,Height[3],Width[2]-gapW,Height[3]);
     line(Width[2]+gapW,Height[3],Width[3]-gapW,Height[3]);
      
      
       //Vertikal
      
       line(Width[0]/2,0+gapH,Zero11.x,Zero11.y);
       line(Width[0]/2,Height[0]+gapH,Zero31.x,Zero31.y);
       line(Width[0]/2,Height[1]+gapH,Zero51.x,Zero51.y);
       line(Width[0]/2,Height[2]+gapH,Zero71.x,Zero71.y);
      
       line(Width[1]+((Width[0]-Width[1])/2),0+gapH,Zero12.x,Zero12.y);
       line(Width[1]+((Width[0]-Width[1])/2),Height[0]+gapH,Zero32.x,Zero32.y);
       line(Width[1]+((Width[0]-Width[1])/2),Height[1]+gapH,Zero52.x,Zero52.y);
       line(Width[1]+((Width[0]-Width[1])/2),Height[2]+gapH,Zero72.x,Zero72.y);
       
       line(Width[2]+((Width[0]-Width[1])/2),0+gapH,Zero21.x,Zero21.y);
       line(Width[2]+((Width[0]-Width[1])/2),Height[0]+gapH,Zero41.x,Zero41.y);
       line(Width[2]+((Width[0]-Width[1])/2),Height[1]+gapH,Zero61.x,Zero61.y);
       line(Width[2]+((Width[0]-Width[1])/2),Height[2]+gapH,Zero81.x,Zero81.y);
     
       line(Width[3]+((Width[0]-Width[1])/2),0+gapH,Zero22.x,Zero22.y);
       line(Width[3]+((Width[0]-Width[1])/2),Height[0]+gapH,Zero42.x,Zero42.y);
       line(Width[3]+((Width[0]-Width[1])/2),Height[1]+gapH,Zero62.x,Zero62.y);
       line(Width[3]+((Width[0]-Width[1])/2),Height[2]+gapH,Zero82.x,Zero82.y);
   
   
   
   
   
   
   }
   
   
   
   
   float[] IK(float Xhip, float Yhip, float Xfoot, float Yfoot, float Zfoot){
    
   
   
    
    
     Xpos = abs(Xhip-Xfoot);                                 //relative distance of Xhip and Xfoot
     Ypos = abs(Yhip-Yfoot);                                 //relative distance of Yhip and Yfoot
      
   
   
     Bleg    = sqrt((Xfoot*Xfoot)+(Zfoot*Zfoot));   //total leg lenght including hL
     Qh      = HALF_PI-asin(Zfoot/Bleg);     // calculation of angle
   
    
   
     Bxz    = Bleg-hL;   //leg length without HL
     B      = sqrt(Bxz*Bxz + Ypos*Ypos);  // lenght between X-,Y-hip and X-,Y-foot
     bxz    = cos(Q1rad)*l1;
   
     q1 = atan2(Ypos,Xpos);
     q2 = acos((l1*l1 - l2*l2 + B*B)/(2*l1*B));              //the law of cosines and converted from radiants into degrees       
     Q1rad = q2 - q1;                                    
     Q1deg = degrees(Q1rad);
     Q2rad = (acos((l1*l1 + l2*l2 - B*B)/(2*l1*l2)));    //the law of cosines and converted from radiants into degrees  
     Q2deg = degrees(Q2rad);
   
   
     hx = sin(Qh)*hL;                                // XYZ position of the outer hip joint
     hy = Yhip;
     hz = cos(Qh)*hL;
    
     ex = (cos(Q1rad)*l1) + hx;                        //XYZ positions of the knee joint  /////////////falsch falsch falsch  keine ahnung was da falsch ist....
     ey = (sin(Q1rad)*l1) + Yhip;
     ez = sin(Qh)*(bxz+hL);     // falsch
    
      float[] DegAndKoor = {Qh,Q1rad,Q2rad,hx,hy,hz,ex,ey,ez,Xfoot,Yfoot,Zfoot,Xpos,Ypos,Xhip,Yhip};  //stores the Values in array
   
      return DegAndKoor;                                                                        // puts out the array
    
   //---------------------------------------------------------------------------------------------------------------------------------
   }
   
   
   
   
   
   void DrawLeg(int leg, float Xhip, float Yhip, float Xfoot, float Yfoot, float Zfoot){
   
    
    
   
    
    
   //koordinaten system nullpunkten
   int[] Height   = {height*1/4,height*2/4,height*3/4,height*4/4};
   int[] Width    = {width*1/4,width*2/4,width*3/4,width*4/4};
   
   
   PVector Zero11 = new PVector(Width[0]/2,Height[0]);
   PVector Zero12 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero21 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero22 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[0]);
   PVector Zero31 = new PVector(Width[0]/2,Height[1]);
   PVector Zero32 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero41 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero42 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[1]);
   PVector Zero51 = new PVector(Width[0]/2,Height[2]);
   PVector Zero52 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero61 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero62 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[2]);
   PVector Zero71 = new PVector(Width[0]/2,Height[3]);
   PVector Zero72 = new PVector(Width[1]+((Width[0]-Width[1])/2),Height[3]);
   PVector Zero81 = new PVector(Width[2]+((Width[0]-Width[1])/2),Height[3]);
   PVector Zero82 = new PVector(Width[3]+((Width[0]-Width[1])/2),Height[3]);
    
   
   float[] ZeroX ={Zero11.x,Zero12.x,Zero21.x,Zero22.x,Zero31.x,Zero32.x,Zero41.x,Zero42.x,Zero51.x,Zero52.x,Zero61.x,Zero62.x,Zero71.x,Zero72.x,Zero81.x,Zero82.x,};
   float[] ZeroY ={Zero11.y,Zero12.y,Zero21.y,Zero22.y,Zero31.y,Zero32.y,Zero41.y,Zero42.y,Zero51.y,Zero52.y,Zero61.y,Zero62.y,Zero71.y,Zero72.y,Zero81.y,Zero82.y,};
   
    
     float[] DegAndKoor = IK(Xhip, Yhip, Xfoot, Yfoot, Zfoot);     //copies the IK array into the new array
    
     float[] Deg   = {DegAndKoor[0],DegAndKoor[1],DegAndKoor[2]};   //copies array into smaller sections for better overview
     PVector h     = new PVector(DegAndKoor[3],DegAndKoor[4],DegAndKoor[5]);
     PVector e     = new PVector(DegAndKoor[6],DegAndKoor[7],DegAndKoor[8]);
     PVector foot  = new PVector(DegAndKoor[9],DegAndKoor[10],DegAndKoor[11]);
     PVector pos   = new PVector(DegAndKoor[12],DegAndKoor[13]);
     PVector hip   = new PVector(DegAndKoor[14],DegAndKoor[15]);
    
   
   SendLeg(leg, Deg);   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// slows down the programm immensly!!!!!!!!!!!!!!!
   
   
   //---------------------------------------------------------------------------------------------------------------------------------
   //--------------------------------------------------------|          ZX Axis              |----------------------------------------
   //--------------------------------------------------------|          drawing leg          |----------------------------------------
   
   strokeWeight(1);
   
   fill(240,0,0,200);
   ellipse(ZeroX[leg],ZeroY[leg]-hip.x,8,8);            //Hip joint
   fill(100,0,100,200);
   line(ZeroX[leg],ZeroY[leg],ZeroX[leg]+h.z,ZeroY[leg]-h.x);     //from the hip joint to the outer hip
   fill(0,100,100,200);
   ellipse(ZeroX[leg]+h.z,ZeroY[leg]-h.x,15,15);        //outer hip joint      
   stroke(2);
   line(ZeroX[leg]+h.z,ZeroY[leg]-h.x,ZeroX[leg]+foot.z,ZeroY[leg]-foot.x);   // from the outer hip joint to the foot
   
   
   fill(240,0,0,200);
   ellipse(ZeroX[leg]+foot.z,ZeroY[leg]-foot.x,8,8);
   
   
   
   
   //--------------------------------------------------------|             end drawing leg             |------------------------------
   //---------------------------------------------------------------------------------------------------------------------------------
   //--------------------------------------------------------|          drawing Reference dots         |------------------------------
   
   fill(100,0,200,100);
   
   ellipse(ZeroX[leg],ZeroY[leg]-foot.x,10,10);  // Xfoot-axis
   text("    Xfoot:  " + foot.x, ZeroX[leg], ZeroY[leg]-foot.x+5);
   
   ellipse(ZeroX[leg]+foot.z,ZeroY[leg],10,10);
   text(" Zfoot:  " + foot.z, ZeroX[leg]+foot.z, ZeroY[leg]+20);
   
   //--------------------------------------------------------|        end drawing Reference dots        |-----------------------------
   //---------------------------------------------------------------------------------------------------------------------------------
   //--------------------------------------------------------|          ZY Axis                         |-----------------------------
   
   
   strokeWeight(1);
   
   fill(240,0,0,200);
   ellipse(ZeroX[leg+8]+foot.z,ZeroY[leg+8]-foot.y,8,8);
   
   //---------------------------------------------------------------------------------------------------------------------------------
   //--------------------------------------------------------|          drawing Reference dots         |------------------------------
   
   fill(100,0,200,100);
   
   ellipse(ZeroX[leg+8],ZeroY[leg+8]-foot.y,10,10);  // Xfoot-axis
   text("    Yfoot:  " + foot.y, ZeroX[leg+8], ZeroY[leg+8]-foot.y+5);
   
   ellipse(ZeroX[leg+8]+foot.z,ZeroY[leg+8],10,10);
   text(" Zfoot:  " + foot.z, ZeroX[leg+8]+foot.z, ZeroY[leg+8]+20);
   
   
   
   //--------------------------------------------------------|        end drawing Reference dots        |-----------------------------
   //---------------------------------------------------------------------------------------------------------------------------------
   
   // naming each sector by leg name
   
   fill(0);
   text("Leg : " +(leg+1) ,ZeroX[leg]-(ZeroX[0]*6/7), ZeroY[leg]-(ZeroY[0]*6/7));
   text("Leg : " +(leg+1) ,ZeroX[leg+8]-(ZeroX[0]*6/7), ZeroY[leg+8]-(ZeroY[0]*6/7));
   text("Qh : " + degrees(Qh) ,ZeroX[leg]-(ZeroX[0]*6/7), ZeroY[leg]-(ZeroY[0]*5/7));
   text("Q1 : " + int((degrees(Q1rad)+90)) ,ZeroX[leg]-(ZeroX[0]*6/7), ZeroY[leg]-(ZeroY[0]*4/7));
   text("Q2 : " + int(degrees(Q2rad)) ,ZeroX[leg]-(ZeroX[0]*6/7), ZeroY[leg]-(ZeroY[0]*3/7));
   
   
   }
   
   
   
   
   
   
   void SendLeg(int leg, float[] Deg){
    
     // Method to write to the arduino
    
       String[] Order = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x"};
   
   
    
     port.write((int (degrees(Deg[0]))) + Order[3*leg]);
     port.write((int (degrees(Deg[1]))+90) + Order[(3*leg)+1]);
     port.write((int (degrees(Deg[2]))) + Order[(3*leg)+2]);  
   }
   
   

PS.
you can do it with that too and see there is no diffrence:
  port.write(1);
  port.write(1);
  port.write(1);

Hey,
I am working on an octapod project and I need IK for that. I found that need litte programm but I can't get it to work with diffrent leg sizes. It only seems to work when "a" and "b" are equal.

Has someone any idea how to solve that??
Thak you very much. because I tried it now for a really long time....


int sx,sy,ex,ey,hx,hy;
int armLength,ua,la;
float uad, lad;
void setup(){
size(500,500);
background(255, 224, 150);
sx = width/2;
sy = height/2;
armLength = int(width/5);
}

void draw(){
fill(255);
rect(0,0,width,height);
upperArm();
}

void upperArm(){
int dx = mouseX - sx;
int dy = mouseY - sy;
float distance = sqrt(dx*dx+dy*dy);

int a = armLength;
int b = armLength;
float c = min(distance, a + b);

float B = acos((b*b-a*a-c*c)/(-2*a*c));
float C = acos((c*c-a*a-b*b)/(-2*a*b));

float D = atan2(dy,dx);
float E = D + B + PI + C;

ex = int((cos(E) * a)) + sx;
ey = int((sin(E) * a)) + sy;
print("UpperArm Angle= "+degrees(E)+" ");

hx = int((cos(D+B) * b)) + ex;
hy = int((sin(D+B) * b)) + ey;
println("LowerArm Angle= "+degrees((D+B)));

stroke(255,0,0,100);
fill(240,0,0,200);
ellipse(sx,sy,10,10);
ellipse(ex,ey,8,8);
ellipse(hx,hy,6,6);
stroke(0);
line(sx,sy,ex,ey);
line(ex,ey,hx,hy);
}