/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/js/dugga_backup_v2.js

  • Committer: gustav.hartvigsson at gmail
  • Date: 2013-04-03 11:52:56 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20130403115256-sz6zermzoom4lifc
Ignored .DS_Store files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/dugga_backup_v2.js
1
 
/********************************************************************************
2
 
 
3
 
   Mouse coordinate and canvas globals
4
 
   
5
 
   Handles both Touch and Mouse/Keyboard input at the same time
6
 
   
7
 
*********************************************************************************/
8
 
 
9
 
                // Mouse coordinate globals
10
 
                var gridx,gridy;
11
 
                var clickstate=0;
12
 
 
13
 
                var acanvas;
14
 
                var context;
15
 
 
16
 
/********************************************************************************
17
 
 
18
 
   Canvas Setup and Click Handling Code
19
 
   
20
 
   Handles both Touch and Mouse/Keyboard input at the same time and executes 
21
 
   handler callbacks.
22
 
   Also declares canvas globals
23
 
 
24
 
*********************************************************************************/
25
 
 
26
 
                function setupcanvas()
27
 
                {
28
 
                                acanvas=document.getElementById('a');
29
 
                                context=acanvas.getContext("2d");               
30
 
                                
31
 
                                setTimeout("foo();",50);
32
 
                                
33
 
                                setupClickHandling();           
34
 
                }
35
 
                
36
 
                function setupClickHandling()
37
 
                {
38
 
                                // Mouse and Keyboard Events
39
 
                                acanvas.addEventListener('mousemove', ev_mousemove, false);
40
 
                                acanvas.addEventListener('mouseup', ev_mouseup, false);
41
 
                                acanvas.addEventListener('mousedown', ev_mousedown, false);
42
 
                                
43
 
                                // Touch Events
44
 
                                acanvas.addEventListener('touchstart', ev_touchstart, false);
45
 
                                acanvas.addEventListener('touchend', ev_touchend, false);
46
 
                                acanvas.addEventListener('touchmove', ev_touchmove, false);             
47
 
                }                                               
48
 
                                
49
 
                // Keyboard/Mouse Mouse Up Handler
50
 
                function ev_mouseup(ev)
51
 
                {
52
 
                                handler_mouseup();
53
 
                }
54
 
                
55
 
                // Keyboard/Mouse Mouse Down Handler
56
 
                function ev_mousedown(ev)
57
 
                {
58
 
                                handler_mousedown();            
59
 
                }
60
 
 
61
 
                // Keyboard/Mouse Mouse Move Handler
62
 
                function ev_mousemove (ev) 
63
 
                {
64
 
                          var cx,cy=0;
65
 
                          if (ev.layerX||ev.layerX==0) { // Firefox
66
 
                                    cx=ev.layerX-acanvas.offsetLeft;
67
 
                                    cy=ev.layerY-acanvas.offsetTop;
68
 
                          } else if (ev.offsetX || ev.offsetX == 0) { // Opera
69
 
                                    cx=ev.offsetX-acanvas.offsetLeft;
70
 
                                    cy=ev.offsetY-acanvas.offsetTop;
71
 
                          }
72
 
 
73
 
                          coord=findPos(acanvas);
74
 
                                cx=cx-coord.x;
75
 
                                cy=cy-coord.y;
76
 
 
77
 
                                handler_mousemove(cx,cy);
78
 
                }               
79
 
 
80
 
                // Touch start event
81
 
                function ev_touchstart(event){  
82
 
                event.preventDefault();  
83
 
                var numtouch = event.touches.length;  
84
 
 
85
 
                                targetEvent =  event.touches.item(0);
86
 
 
87
 
                                var cx = targetEvent.pageX;
88
 
                                var cy = targetEvent.pageY;
89
 
                                
90
 
                                gridx=cx;
91
 
                                gridy=cy;
92
 
 
93
 
                                handler_mousedown();
94
 
 
95
 
                };  
96
 
 
97
 
                // Touch end event
98
 
                function ev_touchend(event){  
99
 
                event.preventDefault();  
100
 
                var numtouch = event.touches.length;  
101
 
 
102
 
                                handler_mouseup();
103
 
                };  
104
 
                
105
 
                // Touch move event
106
 
                function ev_touchmove(event){  
107
 
                event.preventDefault();  
108
 
                var numtouch = event.touches.length;  
109
 
 
110
 
                                targetEvent =  event.touches.item(0);
111
 
 
112
 
                                var cx = targetEvent.pageX;
113
 
                                var cy = targetEvent.pageY;
114
 
                                
115
 
                                handler_mousemove(cx,cy);                               
116
 
                };  
117
 
 
118
 
                // Fix scrolling on touch devices
119
 
                var ScrollFix = function(elem) {
120
 
                    // Variables to track inputs
121
 
                    var startY, startTopScroll;
122
 
                
123
 
                    elem = elem || document.querySelector(elem);
124
 
                
125
 
                    // If there is no element, then do nothing  
126
 
                    if(!elem)
127
 
                        return;
128
 
                
129
 
                    // Handle the start of interactions
130
 
                    elem.addEventListener('touchstart', function(event){
131
 
                        startY = event.touches[0].pageY;
132
 
                        startTopScroll = elem.scrollTop;
133
 
                
134
 
                        if(startTopScroll <= 0)
135
 
                            elem.scrollTop = 1;
136
 
                
137
 
                        if(startTopScroll + elem.offsetHeight >= elem.scrollHeight)
138
 
                            elem.scrollTop = elem.scrollHeight - elem.offsetHeight - 1;
139
 
                    }, false);
140
 
                };
141
 
 
142
 
/********************************************************************************
143
 
 
144
 
   Canvas Diagram Drawing Code
145
 
 
146
 
*********************************************************************************/
147
 
 
148
 
                
149
 
 
150
 
                // Draws a perfect round circle
151
 
                
152
 
                function drawcircle(radius,color)
153
 
                {
154
 
                                context.lineWidth   = 1.5;
155
 
                                context.strokeStyle = color;
156
 
                                context.arc(0, 0, radius, 0 , 2 * Math.PI, false);
157
 
                }
158
 
 
159
 
                // Draws 90 degree arc
160
 
                
161
 
                function drawellipse(x1,y1,x2,y2)
162
 
                {
163
 
 
164
 
                                        var rx=(x2-x1)/2.0;
165
 
                                        var ry=(y2-y1)/2.0;
166
 
 
167
 
                                        var x3=x1+rx;
168
 
                                        var y3=y1+ry;
169
 
 
170
 
                                        context.beginPath();                                    
171
 
 
172
 
                                        context.moveTo(x1,y1+ry);
173
 
                                        context.quadraticCurveTo(x1,y1,x1+rx,y1);
174
 
                                        context.quadraticCurveTo(x2,y1,x2,y1+ry);
175
 
                                        context.quadraticCurveTo(x2,y2,x2-rx,y2);
176
 
                                        context.quadraticCurveTo(x1,y2,x1,y1+ry);
177
 
 
178
 
                                        context.stroke();
179
 
                }       
180
 
                
181
 
                // Draw a point         
182
 
                
183
 
                function point(x,y,col)
184
 
                {
185
 
                                context.strokeStyle="#000";
186
 
                                context.lineWidth = 1;
187
 
                        
188
 
                                context.fillStyle=col;
189
 
                                context.fillRect(x-4,y-4,8,8);          
190
 
                                context.strokeRect(x-4,y-4,8,8);                                                
191
 
                }
192
 
                
193
 
                // Draw a box around a point to indicate highlight
194
 
                
195
 
                function highlight(px,py)
196
 
                {
197
 
                                context.strokeStyle="#aaa";
198
 
                                context.lineWidth = 1;
199
 
                        
200
 
                                context.strokeRect(px-8,py-8,16,16);                                            
201
 
                                
202
 
                }
203
 
                
204
 
                // Draw a line using current context
205
 
                
206
 
                function drawline(x1,y1,x2,y2,strokestyle,linewidth)
207
 
                {
208
 
                                                context.strokeStyle = strokestyle;
209
 
                                                context.lineWidth   = linewidth;
210
 
                                                context.beginPath();
211
 
                                                context.moveTo(x1,y1);
212
 
                                                context.lineTo(x2,y2);
213
 
                                                context.stroke();                                                       
214
 
                }
215
 
                
216
 
                function fourpoints(x1,y1,x2,y2,x3,y3,x4,y4,col)
217
 
                {
218
 
                                point(x1,y1,col);
219
 
                                point(x2,y2,col);
220
 
                                point(x3,y3,col);
221
 
                                point(x4,y4,col);                               
222
 
                }
223
 
                
224
 
                function drawdiamond(x1,y1,rx,ry,expand)
225
 
                {
226
 
                                context.beginPath();                                    
227
 
                                context.moveTo(x1-expand,y1+ry);
228
 
                                context.lineTo(x1+rx,y2+expand);
229
 
                                context.lineTo(x2+expand,y1+ry);
230
 
                                context.lineTo(x1+rx,y1-expand);
231
 
                                context.lineTo(x1-expand,y1+ry);                        
232
 
                                context.stroke();                                                                                       
233
 
                }
234
 
                
235
 
                // Dashed Line in Segments of given size
236
 
                
237
 
                function dashedline(sx,sy,ex,ey,dashlen,linewidth,col)
238
 
                {
239
 
                                                
240
 
                        var dx=ex-sx;
241
 
                        var dy=ey-sy;
242
 
                                                        
243
 
                        len=Math.sqrt((dx*dx)+(dy*dy));
244
 
                        notimes=Math.round(len/dashlen);
245
 
                        
246
 
                        dx=dx/notimes;
247
 
                        dy=dy/notimes;
248
 
                        
249
 
                        context.lineWidth = linewidth;
250
 
                        context.strokeStyle=col;
251
 
 
252
 
                        context.beginPath();
253
 
 
254
 
                        var xk,yk;
255
 
                        xk=sx;
256
 
                        yk=sy;
257
 
                        xh=dx/2.0;
258
 
                        yh=dy/2.0;
259
 
                        for(var i=0;i<notimes;i++){
260
 
 
261
 
                                        context.moveTo(xk,yk);                          
262
 
                                        context.lineTo(xk+xh,yk+yh);
263
 
                                
264
 
                                        xk+=dx;
265
 
                                        yk+=dy;
266
 
                        }
267
 
                                                        
268
 
                        context.stroke();
269
 
                                
270
 
                }
271
 
                                                                
272
 
                // Arcto only works if both x1 and y2 are on circle border
273
 
                
274
 
                function arcto(x0,y0,x1,y1,x2,y2)
275
 
                {
276
 
 
277
 
                                var r = Math.sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0));
278
 
                                var x = x0-r;
279
 
                                var y = y0-r;
280
 
                                var startAngle = (180/Math.PI*Math.atan2(y1-y0, x1-x0));
281
 
                                var endAngle = (180/Math.PI*Math.atan2(y2-y0, x2-x0));
282
 
                                
283
 
                                context.arc(x0, y0, r, 0, Math.PI*2.0, 1.0);
284
 
 
285
 
                }
286
 
 
287
 
                // Draws 90 degree arc
288
 
                
289
 
                function arcdeg(x1,y1,x2,y2,x3,y3)
290
 
                {
291
 
                                        
292
 
 
293
 
                                        // First quadrant positive positive                     
294
 
                                        dashedline(x1,y1,x2,y2,8,1.0,"#999");
295
 
                                        dashedline(x3,y3,x2,y2,8,1.0,"#999");                                   
296
 
 
297
 
                                        point(x1,y1,"#ff5");
298
 
                                        point(x2,y2,"#f55");
299
 
                                        point(x3,y3,"#f55");
300
 
                                                                                                
301
 
                                        k=(y3-y1)/(x3-x1);                                      
302
 
                                                                                
303
 
                                        yk=y1+((x2-x1)*k);
304
 
                                        
305
 
                                        rx=x3-x1;
306
 
                                        ry=y3-y1;
307
 
 
308
 
                                        point(x2,yk,"#f5f");
309
 
 
310
 
                                        context.strokeStyle = '#49f';
311
 
                                        context.lineWidth   = 1.0;                                      
312
 
                                        context.beginPath();                                    
313
 
                                        context.moveTo(x1,y1);
314
 
                                        for(i=0;i<48;i++){
315
 
                                                        if(y3>=y1){
316
 
                                                                        if(yk>=y2){
317
 
                                                                                        context.lineTo(x1+(Math.sin(((Math.PI/96.0)*-i)+(Math.PI*1.0))*rx),y3+(Math.cos(((Math.PI/96.0)*-i)+(Math.PI*1.0))*ry));
318
 
                                                                        }else{
319
 
                                                                                        context.lineTo(x3+(Math.sin(((Math.PI/96.0)*i)+(Math.PI*1.5))*rx),y1+(Math.cos(((Math.PI/96.0)*i)+(Math.PI*1.5))*ry));
320
 
                                                                        }
321
 
                                                        }else{
322
 
                                                                        if(yk<=y2){
323
 
                                                                                        context.lineTo(x1+(Math.sin(((Math.PI/96.0)*-i)+(Math.PI*1.0))*rx),y3+(Math.cos(((Math.PI/96.0)*-i)+(Math.PI*1.0))*ry));
324
 
                                                                        }else{
325
 
                                                                                        context.lineTo(x3+(Math.sin(((Math.PI/96.0)*i)+(Math.PI*1.5))*rx),y1+(Math.cos(((Math.PI/96.0)*i)+(Math.PI*1.5))*ry));
326
 
                                                                        }                                                       
327
 
                                                        }
328
 
                                        }
329
 
                                        context.stroke();
330
 
 
331
 
                }               
332
 
        
333
 
                // function that draws one part of the sun      
334
 
                
335
 
                function sundial(radius,angle,scale)
336
 
                {
337
 
                                
338
 
                                        cosv=Math.cos(angle);
339
 
                                        sinv=Math.sin(angle);
340
 
                                                                                
341
 
                                        yaddx=scale*cosv;
342
 
                                        yaddy=scale*sinv;
343
 
                                        
344
 
                                        xaddx=-scale*sinv;
345
 
                                        xaddy=scale*cosv;
346
 
 
347
 
                                        xk=cosv*radius;
348
 
                                        yk=sinv*radius;
349
 
 
350
 
                                        context.bezierCurveTo((-1.5*xaddx)+(yaddx*1.5)+xk,(-1.5*xaddy)+(yaddy*1.5)+yk,xaddx+(yaddx*2.0)+xk,xaddy+(yaddy*2.0)+yk,xaddx+(yaddx*3.0)+xk,xaddy+(yaddy*3.0)+yk);
351
 
                                        context.bezierCurveTo(xaddx+yaddx+xk,xaddy+yaddy+yk,(1.5*xaddx)+yaddx+xk,(1.5*xaddy)+yaddy+yk,(3.0*xaddx)+xk,(3.0*xaddy)+yk);
352
 
                }
353
 
 
354
 
                // function that daws the sun
355
 
                
356
 
                function drawsun()
357
 
                {
358
 
                                context.fillStyle = "#fe9";
359
 
                                context.strokeStyle = "#d82";
360
 
                                context.lineWidth   = 1.5;
361
 
                                                                 
362
 
                                context.beginPath();
363
 
                                context.moveTo(30,0);
364
 
                                for(i=0.0;i<360.0;i+=22.5){
365
 
                                                angle=(i/360.0)*2*Math.PI;
366
 
                                                sundial(30,angle,3);
367
 
                                }
368
 
                                context.stroke();
369
 
                                context.fill();                                                                                                                 
370
 
                }
371
 
                
372
 
                // Draws the ball (used in various examples)
373
 
                
374
 
                function drawball(cx,cy,radie,innerradie,ballradie,col1,inangle,inangleadd)
375
 
                {
376
 
                                        
377
 
                                        angleadd=(inangleadd/360.0)*2*Math.PI;
378
 
                                                                        
379
 
                                        context.fillStyle = col1;                                       
380
 
                                        
381
 
                                        for(i=0;i<360;i+=inangle){
382
 
                                                                                                                
383
 
                                                        angle=(i/360.0)*2*Math.PI;
384
 
                                                        angle2=angle+angleadd;
385
 
                                                        angle3=angle+(angleadd*2.0);
386
 
                                                        angle4=angle-angleadd;
387
 
 
388
 
                                                        cosv=Math.cos(angle);
389
 
                                                        sinv=Math.sin(angle);
390
 
 
391
 
                                                        cosv2=Math.cos(angle2);
392
 
                                                        sinv2=Math.sin(angle2);
393
 
 
394
 
                                                        cosv4=Math.cos(angle4);
395
 
                                                        sinv4=Math.sin(angle4);
396
 
                                                        
397
 
                                                        context.beginPath();
398
 
 
399
 
                                                        context.moveTo(cx,cy);
400
 
                                                        context.quadraticCurveTo(cx+(cosv*innerradie),cy+(sinv*innerradie),cx+(cosv2*radie),cy+(sinv2*radie));                                                  
401
 
                                                        context.arc(cx,cy,radie,angle2,angle,1.0);
402
 
                                                        context.quadraticCurveTo(cx+(cosv4*innerradie),cy+(sinv4*innerradie),cx,cy);                                                    
403
 
                                                                                                                
404
 
                                                        context.fill();                                                                                                                 
405
 
                                                        
406
 
                                        }       
407
 
                                        
408
 
 
409
 
                                        context.beginPath();
410
 
                                        context.lineWidth   = 1.5;
411
 
                                        context.fillStyle = "#fff";
412
 
                                        context.arc(0, 0, ballradie, 0 , 2 * Math.PI, false);
413
 
                                        context.fill();                                                                                                                 
414
 
                                                                                                        
415
 
                                        context.beginPath();
416
 
                                        context.arc(cx,cy,radie,0,Math.PI*2.0,1.0);                                                                                             
417
 
                                        context.stroke();                                                                                                                       
418
 
                
419
 
                }
420
 
                
421
 
                
422
 
/********************************************************************************
423
 
 
424
 
   Canvas and Diagram Measuring Functions
425
 
   
426
 
        These functions allow us to measure pixels in diagram and other apps
427
 
 
428
 
*********************************************************************************/
429
 
                
430
 
                
431
 
                // Recursive Pos of div in document - should work in most browsers
432
 
                
433
 
                function findPos(obj) {
434
 
                        var curleft = curtop = 0;
435
 
                        if (obj.offsetParent) {
436
 
                                curleft = obj.offsetLeft
437
 
                                curtop = obj.offsetTop
438
 
                                while (obj = obj.offsetParent) {
439
 
                                        curleft += obj.offsetLeft
440
 
                                        curtop += obj.offsetTop
441
 
                                }
442
 
                        }
443
 
                        return {
444
 
                                                x:curleft,
445
 
                                                y:curtop
446
 
                                }
447
 
                }
448
 
                
449
 
                // Make side coordinates for drawing Model
450
 
 
451
 
                function makeside(side,x1,y1,x2,y2,perc){
452
 
        
453
 
                                var xk=0;
454
 
                                var yk=0;
455
 
        
456
 
                                if(side==1){
457
 
                                                xk=x1;
458
 
                                                yk=y1+((y2-y1)*perc);
459
 
                                }else if(side==2){
460
 
                                                xk=x1+((x2-x1)*perc);
461
 
                                                yk=y2;
462
 
                                }else if(side==3){
463
 
                                                xk=x2;
464
 
                                                yk=y1+((y2-y1)*perc);                                           
465
 
                                }else if(side==4){
466
 
                                                xk=x1+((x2-x1)*perc)
467
 
                                                yk=y1;
468
 
                                }
469
 
                                
470
 
                                return {
471
 
                                                        x:xk,
472
 
                                                        y:yk
473
 
                                        }
474
 
                
475
 
                }               
476
 
                
477
 
                // Computes side identifier for a mouse coordinate and object coordinates
478
 
                
479
 
                function computeside(x,y,x1,y1,x2,y2,sidetol){
480
 
        
481
 
                                var obj_sidentifier="None";
482
 
                                var obj_sideperc=0;
483
 
                                var obj_centerdist=0;
484
 
        
485
 
                                // Left Side
486
 
                                if(x>x1-sidetol&&x<x1+sidetol&&y>y1-sidetol&&y<y2+sidetol){
487
 
                                                obj_sidentifier=1;
488
 
                                                obj_sideperc=makesideperc(y,y1,y2);
489
 
                                                obj_centerdist=centerdist(y,y1,y2);
490
 
                                }
491
 
 
492
 
                                // Bottom Not Including Left Side or Right Side
493
 
                                if(x>x1+sidetol&&x<x2-sidetol&&y>y2-sidetol&&y<y2+sidetol){
494
 
                                                obj_sidentifier=2;
495
 
                                                obj_sideperc=makesideperc(x,x1,x2);
496
 
                                                obj_centerdist=centerdist(x,x1,x2);
497
 
                                }
498
 
 
499
 
                                // Right Side
500
 
                                if(x>x2-sidetol&&x<x2+sidetol&&y>y1-sidetol&&y<y2+sidetol){
501
 
                                                obj_sidentifier=3;
502
 
                                                obj_sideperc=makesideperc(y,y1,y2);
503
 
                                                obj_centerdist=centerdist(y,y1,y2);
504
 
                                }
505
 
                                
506
 
                                // Top Not Including Left Side or Right Side
507
 
                                if(x>x1+sidetol&&x<x2-sidetol&&y>y1-sidetol&&y<y1+sidetol){
508
 
                                                obj_sidentifier=4;
509
 
                                                obj_sideperc=makesideperc(x,x1,x2);
510
 
                                                obj_centerdist=centerdist(x,x1,x2);
511
 
                                }
512
 
                                
513
 
                                return {
514
 
                                                        side:obj_sidentifier,
515
 
                                                        perc:obj_sideperc,
516
 
                                                        dist:obj_centerdist
517
 
                                        }
518
 
                
519
 
                }               
520
 
                                                
521
 
                // Make side perc for ER model
522
 
                
523
 
                function makesideperc(x,x1,x2){
524
 
                                r=x2-x1;
525
 
                                perc=(x-x1)/r;
526
 
 
527
 
                                if(perc>1.0) perc=1.0;
528
 
                                if(perc<0.0) perc=0.0;
529
 
 
530
 
                                return perc;
531
 
                }
532
 
                
533
 
                function centerdist(x,x1,x2){
534
 
                                r=x1+((x2-x1)*0.5);
535
 
                                
536
 
                                return (x-r);
537
 
                }
538
 
                
539
 
                // Euclidian distance - Yo!
540
 
                
541
 
                function distance(x1,y1,x2,y2){
542
 
                                
543
 
                                var dist=Math.sqrt(((y2-y1)*(y2-y1))+((x2-x1)*(x2-x1)));
544
 
                                
545
 
                                return dist;
546
 
                }
547
 
 
548
 
                // Are we over a line or not.
549
 
 
550
 
                function overline(x,y,x1,y1,x2,y2,tolerance)
551
 
                {
552
 
                                var distance=10000;
553
 
                                
554
 
                                
555
 
                                dx=x2-x1;
556
 
                                dy=y2-y1;
557
 
                                
558
 
                                straighttolerance=2.0;
559
 
                                
560
 
                                // Straight X, Straight Y or Positive or Negative Incline
561
 
                                if(Math.abs(dx)<straighttolerance){
562
 
                                                if(y1<y2){
563
 
                                                                if(y>y1-tolerance&&y<y2+tolerance){
564
 
                                                                                distance=Math.abs(x1-x);
565
 
                                                                }
566
 
                                                }else{
567
 
                                                                if(y>y2-tolerance&&y<y1+tolerance){
568
 
                                                                                distance=Math.abs(x1-x);
569
 
                                                                }                                               
570
 
                                                }
571
 
                                                
572
 
                                                drawline(x1,y1,x2,y2,"#ff0",2.0);
573
 
 
574
 
                                }else if(Math.abs(dy)<straighttolerance){
575
 
                                                if(x1<x2){
576
 
                                                                if(x>x1-tolerance&&x<x2+tolerance){
577
 
                                                                                distance=Math.abs(y1-y);
578
 
                                                                }
579
 
                                                }else{
580
 
                                                                if(x>x2-tolerance&&x<x1+tolerance){
581
 
                                                                                distance=Math.abs(y1-y);
582
 
                                                                }
583
 
                                                }
584
 
                                                drawline(x1,y1,x2,y2,"#ff0",2.0);
585
 
                                }else if(Math.abs(dx)>=Math.abs(dy)){
586
 
                                                k=dy/dx;
587
 
                                                
588
 
                                                yk=y1+((x-x1)*k);
589
 
                                                distance=Math.abs(yk-y);
590
 
                                                
591
 
                                                point(x,yk,"#f5f");
592
 
                                                point(x1,y1,"#fff");                                            
593
 
                                                point(x2,y2,"#fff");                                            
594
 
                                                
595
 
                                                drawline(x1,y1,x2,y2,"#f00",2.0);
596
 
                                }else if(Math.abs(dx)>=Math.abs(dy)){
597
 
                                                k=dy/dx;
598
 
                                                
599
 
                                                yk=y1+((x-x1)*k);
600
 
                                                distance=Math.abs(yk-y);
601
 
                                                
602
 
                                                point(x,yk,"#f5f");
603
 
                                                point(x1,y1,"#fff");                                            
604
 
                                                point(x2,y2,"#fff");
605
 
                                                
606
 
                                                drawline(x1,y1,x2,y2,"#0f0",2.0);                                               
607
 
                                
608
 
                                }
609
 
                                                                
610
 
                                return distance;                
611
 
                }
 
 
b'\\ No newline at end of file'