उपसंहार आरेखण


22

एक एपीकाइक्लोइड एक वक्र है जो एक वृत्त पर एक बिंदु बनाता है क्योंकि यह दूसरे सर्कल के चारों ओर घूमता है। एक साइक्लॉगन एक आकृति है जो एक नियमित बहुभुज पर एक बिंदु बनाता है क्योंकि यह एक विमान में घूमता है । एक एपिकैक्लोजन एक वक्र है जिसे एक नियमित बहुभुज पर एक बिंदु द्वारा पता लगाया जाता है क्योंकि यह दूसरे के चारों ओर घूमता है।

एक प्रोग्राम है जो एक epicyclogon दिया ड्रॉ लिखें r, r1, r2, n1, n2:

r = number of clockwise revolutions rolling polygon makes around stationary polygon (any real number as limited by float values) 
r1 = distance from center of stationary polygon to each of its vertices (positive real number)
r2 = distance from center of rolling polygon to each of its vertices (positive real number)
n1 = number of sides stationary polygon has (integer greater than 2)
n2 = number of sides rolling polygon has (integer greater than 2)

टिप्पणियाँ

  • जब rनकारात्मक है तो रोलर को वामावर्त जाना चाहिए ।
  • के लिए r, एक क्रांति तब होता है जब रेखा बाहर 360 डिग्री पूर्ण दो आकृतियों स्वीप centroids के जोड़ने। के सभी मूल्यों को शामिल करने के लिए इस धारणा का विस्तार किया जाता है r। (इसलिए एक चौथाई क्रांति में सेंट्रोइड्स को जोड़ने वाली रेखा 90 डिग्री बाहर निकल जाती है।)
  • इन तर्कों को कमांड लाइन से आना चाहिए या आपके कार्यक्रम को उनके लिए संकेत देना चाहिए (जैसे कि पायथन के साथ input())।
  • r1और r2एक दूसरे के सापेक्ष हैं, छवि के आयाम नहीं। तो आप किसी भी संख्या में वास्तविक पिक्सेल होने के लिए एक "यूनिट" सेट कर सकते हैं।

बिंदु जिसे आपको ट्रेस करना चाहिए, वह रोलिंग आकार के कोने में से एक है। आकृतियों को इस शीर्ष के साथ शुरू होना चाहिए जो एक स्थिर शिखर और आसन्न दो पक्षों को छूता है:

एपिकालॉग्लोन उदाहरण

सटीक शुरुआती कोने और स्थिर बहुभुज का कोण कोई फर्क नहीं पड़ता।

उत्पादन

आउटपुट को एक छवि पर जाना चाहिए जो कम से कम 600x600 पिक्सल (या कुछ चर आयाम 600 से सेट किया जा सकता है)। यह मापदंडों द्वारा निर्दिष्ट पूरे एपिकैक्लोजन वक्र को दिखाता है, जो छवि में अच्छी तरह से तैयार किया गया है।

रोलिंग और स्थिर बहुभुज भी खींचे जाने चाहिए (अंतिम स्थिति में रोलर के साथ)। दो आकृतियों और एपिकैक्लोजन को तीन अलग-अलग रंगों का होना चाहिए।

वहाँ भी करने के लिए एक आसान तरीका होना चाहिए नहीं बहुभुज (का एक परिवर्तन आकर्षित trueकरने के लिए falseकोड suffices में)।

कृपया हमें कम से कम 2 आउटपुट चित्र दिखाएं। यदि आवश्यक हो तो उन्हें सिकोड़ना ठीक है।

स्कोरिंग

सबसे छोटा कोड जो वैध आउटपुट चित्र बनाता है वह जीतता है।

बोनस

  • माइनस 50 बाइट्स यदि आउटपुट खींचा जा रहा वक्र का एक एनिमेटेड gif (या समान) है।
  • माइनस 150 बाइट्स यदि आप करते हैं n1और n2मान 2 ले, जिससे कि आकार लंबाई की रेखा खंड बन 2 * r1(या r2एक दूसरे के आसपास), "रोलिंग"। rजब आप संभालते हैं जब 2 होते हैं n1और n2आप पर निर्भर होते हैं क्योंकि सेंट्रोइड एक दूसरे के चारों ओर घूमते नहीं हैं तो वे अन्य मामलों में करते हैं। ("रोलिंग" बिल्कुल भी इसे संभालने के रूप में नहीं गिना जाता है।)

चूंकि मैं इस उपन्यास के विचार को अच्छी तरह से निष्पादित करने के लिए उत्सुक हूं (और यह वास्तव में एक काकवॉक नहीं है), मैं विजेता को 150 बाउंटी प्रतिनिधि देने जा रहा हूं । प्रतियोगिता उसी दिन समाप्त हो जाएगी जब बाउंटी रन आउट हो जाएगी।

विजेता को पुरस्कार नहीं दिया जाएगा यदि यह स्पष्ट है कि वे बस एक और सबमिशन से अधिकांश कोड को फिर से लिख रहे हैं।

लाइब्रेरी फ़ंक्शंस जो पहले से ही ऐसा करते हैं (यदि कोई हो) की अनुमति नहीं है।

नोट: यह मेरे बचे हुए सवालों से आया है कि कोई भी पोस्ट करने के लिए स्वतंत्र है। लेकिन अगर कोई और उन्हें पोस्ट नहीं करता है तो मुझे समय में एक अच्छा मौका मिलेगा। : पी


मुझे लगता है कि इसके बजाय एंटीक्लॉकवाइज सकारात्मक होना चाहिए।
सोहम चौधरी

3
@SohamChowdhury मुझे लगता है कि यह शायद ही मायने रखता है।
केल्विन के शौक

आप वास्तव में सही हैं। क्या आपके पास कोई उदाहरण चित्र हैं? मेरे पास सीडीएफ प्लेयर नहीं है।
सोहम चौधरी

@githubphagocyte मैं आपकी बात देखता हूं। फिक्स्ड।
केल्विन के शौक

@ मार्टिनबटनर बहुत सख्त नहीं थे, हालांकि यह मेरे लिए पहली बात थी। यदि आवश्यक हो तो आप दूसरे तरीके से मूल्यों के लिए संकेत कर सकते हैं।
केल्विन के शौक

जवाबों:


3

MATLAB: 735 बाइट्स - 200 बोनस = 535

मेरा कार्यक्रम n = 2 मामले को संभालता है और एक वास्तविक समय एनीमेशन खींचता है। गोल्फ और अनलॉक्ड संस्करणों के बीच कुछ अंतर हैं:

savegif = 1कोड में सेटिंग के द्वारा केवल ungolfed संस्करण में फ़ाइल 'g.gif' के लिए एनीमेशन को सहेजने का विकल्प होता है । यह डिफ़ॉल्ट रूप से बंद है क्योंकि यह कुछ कारणों से कष्टप्रद हो सकता है:

  • अवांछित फाइल का निर्माण
  • संभव अंतराल
  • यदि आपके पास कई मॉनीटर हैं, तो एक त्रुटि उत्पन्न होती है और प्लॉट विंडो दाईं ओर नहीं है ... जीआईएफ बचत को गोल्फ संस्करण में छोड़ना पड़ा क्योंकि इसमें बोनस के आकार को पार करते हुए लगभग 100 बाइट्स थे।

अनलॉक्ड संस्करण ट्रैसर वर्टेक्स पर एक सर्कल खींचता है। यह अधिक फ्रेम भी तैयार करता है और तेजी से आगे बढ़ता है (हालांकि इसे संख्याओं को बदलकर गोल्फ संस्करण में समायोजित किया जा सकता है)।

नमूने:

f(11,5,90,2,99,0) कार्यक्रम समाप्ति के बाद

गोल्फ का नमूना

epic(1.3,4,2,6,6,1) gif आउटपुट के साथ

अनप्लग्ड नमूना

अघोषित कोड

%epicyclogon animation outputs to 'g.gif' if savegif=1 as well as animating in real time

function[] = epic(r,r1,r2,n1,n2,dispPoly)

savegif = 0;  %set to 1 to write .gif

cs = @(a) [cos(a);sin(a)];
vert = @(r, n, v) r * cs(2*pi*v/n);
polyPt = @(l, s, n, r) vert(r, n, floor(l/s)) + mod(l/s,1)*(vert(r, n, floor(l/s)+1) - vert(r, n, floor(l/s)));
polyPt2 = @(i, f, n, r) vert(r, n, i) + f*(vert(r, n, i+1) - vert(r, n, i));
rotm = @(a) [cos(a) -sin(a);sin(a) cos(a)];
arrpluspt = @(a, p) a + kron(p, ones(1,length(a)));
arg = @(p) atan2(p(2), p(1));

E = 1e-9;

dispPoly = dispPoly / dispPoly;

sgn = sign(-r);
r = abs(r);

s1 = 2*r1*sin(pi/n1);
s2 = 2*r2*sin(pi/n2);

%d1 = (r1*r1 - s1*s1*.25)^.5;
d2 = (r2*r2 - s2*s2*.25)^.5;

plotmax = r1+2*r2;

astep = .05; %determines amount of frames per rotation
delay = .01; % time per frame

l = 0;

lRem = 0;
lr = 0;

P1 = vert(r1, n1, 1:n1+1) * dispPoly; 
trace = [];

first = 1;
while 1

    if lr %exists while rotating about a corner of the stationary
        rotA = 2*pi/n1;
    else
        rotA = 2*pi/n2;
    end
    rotPt = polyPt(l, s1, n1, r1);
    lb = l + lRem;
    side1 = floor(l / s1 - E);
    side1up = side1 + lr;
    p2cen = polyPt2(side1, lb/s1 -side1 - .5 * s2/s1, n1, r1) + d2 * cs(2*pi*(side1+.5)/n1);
    if first
        p2cen0 = p2cen;
        r = r + arg(p2cen0)/(2*pi);
    end

    for a = 0:astep:rotA    
        P2 = vert(r2, n2, 0:n2);
        P2 = rotm( pi +pi/n1 -pi/n2   +2*pi*side1/n1) * P2;
        P2 = arrpluspt(P2, p2cen);
        P2 = arrpluspt(P2, -rotPt);
        P2 = rotm(a) * P2;
        P2 = arrpluspt(P2, rotPt);
        trV = mod(floor(l/s2 + E) + lr, n2) + 1;

        cen = rotm(a) * (p2cen - rotPt) + rotPt;
        trace = [trace,P2(:,trV)]; 

        plot(P1(1,:), sgn*P1(2,:), P2(1,:)*dispPoly, sgn*P2(2,:)*dispPoly, trace(1,:),sgn*trace(2,:),P2(1,trV), sgn*P2(2,trV),'o');

        %plot(P1(1,:), P1(2,:), P2(1,:), P2(2,:), trace(1,:),trace(2,:),...
        %[0,p2cen0(1)],[0,p2cen0(2)],[0,cen(1)],[0,cen(2)], P2(1,trV), P2(2,trV),'o');

        axis([-plotmax,plotmax,-plotmax,plotmax]);
        axis square
        figure(1);
       if savegif
           drawnow
           frame = getframe(1); % plot window must be on same monitor!
           img = frame2im(frame);
           [img1,img2] = rgb2ind(img,256);
       end
       if first
           if savegif
               imwrite(img1,img2,'g','gif','DelayTime',2*delay); %control animation speed(but not really)
           end
           first = 0;
       else
           if savegif
               imwrite(img1,img2,'g','gif','WriteMode','append','DelayTime', 2*delay);
           end
       end
       pause(.01);

        adf = mod(arg(cen) - r*2*pi, 2*pi);
        if adf < astep & l/(n1*s1) + .5 > r
            return
        end

    end

%cleanup for next iteration 
    jump = lRem + ~lr * s2; 
    lnex = l + jump; 

    if floor(lnex / s1 - E) > side1up 
        lnex = s1*(side1up+1);
        lRem = jump - (lnex - l);
        lr = 1;
    else    
        lRem = 0;
        lr = 0;
    end
    l = lnex;
end

गोल्फ कोड

function[]=f(r,h,H,n,N,d)
P=pi;T=2*P;F=@floor;C=@(a)[cos(a);sin(a)];g=@(i,f,n,r)r*C(T*i/n)*(1-f)+f*r*C(T*(i+1)/n);R=@(a)[C(a),C(a+P/2)];W=@(a,p)[a(1,:)+p(1);a(2,:)+p(2)];b=@(p)atan2(p(2),p(1));E=1e-9;d=d/d;S=1-2*(r>0);r=-r*S;x=2*h*sin(P/n);X=2*H*sin(P/N);M=h+2*H;l=0;z=0;L=0;A=h*C(T*(0:n)/n)*d;t=[];while 1
v=l/x;D=F(v-E);q=g(D,v-D,n,h);Z=D+L;c=g(D,v+z/x-D-.5*X/x,n,h)+H*cos(P/N)*C(T*D/n+P/n);r=r+~(l+L)*b(c)/T;for a=0:.1:T/(L*n+~L*N)
O=@(p)W(R(a)*W(p,-q),q);B=O(W(R(P+P/n-P/N+T*D/n)*H*C(T*(0:N)/N),c));t=[t,B(:,mod(F(l/X+E)+L,N)+1)];plot(A(1,:),S*A(2,:),d*B(1,:),d*S*B(2,:),t(1,:),t(2,:)*S)
axis([-M,M,-M,M],'square');pause(.1);if.1>mod(b(O(c))-r*T,T)&v/n+.5>r
return;end;end;j=z+~L*X;J=l+j;L=F(J/x-E)>Z;l=L*x*(Z+1)+~L*J;z=L*(J-l);end

निर्देश:

फ़ंक्शन को उसी नाम के साथ फ़ाइल में सहेजें, epic.mया f.m। Matlab कंसोल से फ़ंक्शन को कॉल करके इसे चलाएं।

उपयोग: epic(r, r1, r2, n1, n2, dispPoly) जहां dispPolyएक बूलियन चर है (शून्य यदि गलत है, तो एक गैर-शून्य संख्या यदि सही है) यह निर्धारित करते हुए कि बहुभुज आकर्षित करना है या नहीं।

संपादित करें: एनिमेटेड छवि के लिए 50 का जोड़ा गया बोनस।


14

जावा - 2,726 2,634 - 200 = 2434 वर्ण

3800 ईश बाइट्स से सुधार हुआ

आपके सुझावों के लिए सभी को धन्यवाद (विशेष रूप से pseudonym117), यहाँ नया संस्करण है।

मैंने एक वर्ग P जोड़ा जो बिंदु वर्ग है और एक वर्ग L जो ArrayList का विस्तार करता है

मैंने कुछ मामूली तर्क परिवर्तन भी किए।

यहाँ मुख्य वर्ग है (गोल्फ नहीं):

import java.awt.*;
import java.awt.geom.*;

import javax.swing.*;
public class Polygons2 extends JPanel{
    public static void main(String[] args) throws InterruptedException{new Polygons2(args);}
    double q=Math.PI*2;
    int d=1;
    public Polygons2(String[] args) throws InterruptedException{
        double revolutions=Double.valueOf(args[0])*q;
        double stationaryRadius = Double.valueOf(args[1]);
        double rollingRadius = Double.valueOf(args[2]);
        int stationarySides = Integer.valueOf(args[3]);
        int rollingSides = Integer.valueOf(args[4]);    
        double dist = stationaryRadius+rollingRadius+70;
        P sp = new P(dist,dist);
        P rp = new P(sp.x,sp.y-rollingRadius-stationaryRadius);
        //get points for rolling polygon and stationary polygon
        int key=0;
        for(double stationaryAngle=-q/4;stationaryAngle<q-q/4;stationaryAngle+=q/stationarySides){
            P p=new P(Math.cos(stationaryAngle)*stationaryRadius+sp.x,Math.sin(stationaryAngle)*stationaryRadius+sp.y);
            p.k=key;key++;
            stationaryPoints.add(p);
        }
        for(double rollingAngle=q/4;rollingAngle<q+q/4;rollingAngle+=q/rollingSides){
            P p=new P(Math.cos(rollingAngle)*rollingRadius+rp.x,Math.sin(rollingAngle)*rollingRadius + rp.y);
            p.k=key;key++;
            rollingPoints.add(p);
        }
        double g=(q/2)-((q/2-(q/rollingSides))/2) - ((q/2-(q/stationarySides))/2)-.05;
        for(P p:rollingPoints){p.r(getPoint(0), g);}
        //set up JFrame
        JFrame f = new JFrame();
        f.add(this);
        f.setSize((int)dist*2+60,(int)dist*2+60);
        f.setVisible(true);
        int[] pKeys= new int[]{stationaryPoints.get(0).k,rollingPoints.get(0).k};
        int index=1;
        P rc = rollingPoints.c();
        P sc =stationaryPoints.c();
        double currentRadian=Math.atan2(rc.y-sc.y,rc.x-sc.x);
        double totalRadian = 0;
        while(Math.abs(totalRadian)<revolutions){
            P rc2 = rollingPoints.c();
            P sc2 =stationaryPoints.c();
            double angle = Math.atan2(rc2.y-sc2.y,rc2.x-sc2.x);
            if(currentRadian-angle<2){totalRadian+=(angle-currentRadian);}
            currentRadian=angle;
            L clone=(L)path.clone();
            clone.add(new P(rollingPoints.get(1).x,rollingPoints.get(1).y));
            path = clone;
            for(P p:rollingPoints){
                p.r(getPoint(pKeys[index]),.01);
                int size = stationaryPoints.size();
                for(int i=0;i<size;i++){
                    P stationaryPointAtI = stationaryPoints.get(i);
                    P nextPoint=null;
                    if(i==size-1){nextPoint=stationaryPoints.get(0);}
                    else{nextPoint=stationaryPoints.get(i+1);}
                    if(p.b(stationaryPointAtI, nextPoint)==1&&containsKey(pKeys,p.k)==0){
                        //rolling point is between 2 stationary points
                        if(index==1){index=0;}else{index=1;}
                        pKeys[index]=p.k;
                    }
                    int size2=rollingPoints.size();
                    for(int h=0;h<size2;h++){
                        P nextPoint2=null;
                        if(h==size2-1){nextPoint2=rollingPoints.get(0);}
                        else{nextPoint2=rollingPoints.get(h+1);}
                        if(stationaryPointAtI.b(rollingPoints.get(h), nextPoint2)==1&&containsKey(pKeys,stationaryPointAtI.k)==0){
                            //stationary point is between 2 rolling points
                            if(index==1){index=0;}else{index=1;}
                            pKeys[index]=stationaryPointAtI.k;
                        }
                    }
                }
            }
            repaint();
            Thread.sleep(5);
        }
    }
    volatile L path = new L();
    L rollingPoints = new L();
    L stationaryPoints = new L();
    P getPoint(int key){
        for(P p:rollingPoints){if(p.k==key){return p;}}
        for(P p:stationaryPoints){if(p.k==key){return p;}}
        return null;
    }
    int containsKey(int[] keys,int key){
        for(int i:keys){if(key==i){return 1;}}
        return 0;
    }
    @Override
    public void paintComponent(Graphics g){
        Path2D.Double sPath = new Path2D.Double();
        sPath.moveTo(stationaryPoints.get(0).x, stationaryPoints.get(0).y);
        for(P p:stationaryPoints){
            sPath.lineTo(p.x, p.y);
        }
        sPath.closePath();
        Path2D.Double rPath = new Path2D.Double();
        rPath.moveTo(rollingPoints.get(0).x, rollingPoints.get(0).y);
        for(P p:rollingPoints){
            rPath.lineTo(p.x, p.y);
        }
        rPath.closePath();
        g.setColor(Color.white);
        g.fillRect(0,0,getWidth(),getHeight());
        Graphics2D t = (Graphics2D)g;
        if(d==1){
        t.setColor(Color.black);
        t.draw(sPath);
        t.setColor(Color.blue);
        t.draw(rPath);
        }
        g.setColor(Color.green);
        for(P p:path){g.fillOval((int)p.x-1, (int)p.y-1, 2, 2);}
    }
}

और गोल्फ संस्करण:

import java.awt.*;import java.awt.geom.*;import javax.swing.*;import static java.lang.Math.*;class Polygons2Golfed extends JPanel{public static void main(String[]a)throws Exception{new Polygons2Golfed(a);}double q=PI*2;int d=1;public Polygons2Golfed(String[]a)throws Exception{double b,c,f;b=Double.valueOf(a[1]);c=Double.valueOf(a[2]);int d,e;d=Integer.valueOf(a[3]);e=Integer.valueOf(a[4]);f=b+c+100;P o=new P(f,f);P r=new P(o.x,o.y-c-b);int s=0;for(double u=-q/4;u<q-q/4;u+=q/d){P p=new P(cos(u)*b+o.x,sin(u)*b+o.y);p.k=s;s++;l.add(p);}for(double u=q/4;u<q+q/4;u+=q/e){P p=new P(cos(u)*c+r.x,sin(u)*c+r.y);p.k=s;s++;k.add(p);}double g=q/e/2+q/d/2-.05;for(P p:k){p.r(v(0),g);}JFrame j=new JFrame();j.add(this);j.setSize((int)f*2+60,(int)f*2+60);j.setVisible(true);m=new int[]{l.get(0).k,k.get(0).k};int ad=1;P rc=k.c();P sc=l.c();double ab,ac;ab=atan2(rc.y-sc.y,rc.x-sc.x);ac=0;while(abs(ac)<Double.valueOf(a[0])*q){P rc2=k.c();P sc2=l.c();double ah=atan2(rc2.y-sc2.y,rc2.x-sc2.x);if(ab-ah<2)ac+=(ah-ab);ab=ah;L ag=(L)n.clone();ag.add(new P(k.get(1).x,k.get(1).y));n=ag;for(P p:k){p.r(v(m[ad]),.01);int af=l.size();for(int i=0;i<af;i++){P aa=l.get(i);P w=null;if(i==af-1){w=l.get(0);}else{w=l.get(i+1);}if(p.b(aa, w)==1&&w(p.k)==0){if(ad==1)ad=0;else ad=1;m[ad]=p.k;}int ae=k.size();for(int h=0;h<ae;h++){P u=null;if(h==ae-1)u=k.get(0);else u=k.get(h+1);if(aa.b(k.get(h),u)==1&&w(aa.k)==0){if(ad==1)ad=0;else ad=1;m[ad]=aa.k;}}}}repaint();Thread.sleep(5);}}L n=new L();L k=new L();L l=new L();P v(int key){for(P p:k){if(p.k==key)return p;}for(P p:l){if(p.k==key)return p;}return null;}int[]m;int w(int key){for(int i:m){if(key==i)return 1;}return 0;}@Override public void paintComponent(Graphics g){Path2D.Double aq=new Path2D.Double();aq.moveTo(l.get(0).x,l.get(0).y);for(P p:l){aq.lineTo(p.x, p.y);}aq.closePath();Path2D.Double aw=new Path2D.Double();aw.moveTo(k.get(0).x, k.get(0).y);for(P p:k){aw.lineTo(p.x, p.y);}aw.closePath();g.setColor(Color.white);g.fillRect(0,0,getWidth(),getHeight());Graphics2D t=(Graphics2D)g;if(d==1){t.setColor(Color.black);t.draw(aq);t.setColor(Color.blue);t.draw(aw);}g.setColor(Color.green);for(P p:n){g.fillOval((int)p.x-1,(int)p.y-1,2,2);}}}

साथ ही कक्षा P:

import java.awt.geom.*;class P{double x,y;public P(double a,double b){x=a;y=b;}int k;void r(P c,double g){double a,r;a=Math.atan2(y-c.y,x-c.x)+g;r=Math.sqrt((c.x-x)*(c.x-x)+(c.y-y)*(c.y-y));x=Math.cos(a)*r+c.x;y=Math.sin(a)*r+c.y;}public int b(P a,P b){if(Line2D.ptSegDist(a.x,a.y,b.x,b.y,x,y)<.5)return 1;return 0;}}

और मैं:

import java.util.*;public class L extends ArrayList<P>{public P c(){double x,y;x=0;y=0;for(P p:this){x+=p.x;y+=p.y;}return new P(x/size(),y/size());}}

बहुभुज दिखाने के लिए int d को 0 या 1 में बदलें

तर्क - १ १०० ५० ५ २

यहां छवि विवरण दर्ज करें

आर्ग्स - 1.5 100 100 7 3

यहां छवि विवरण दर्ज करें

आर्ग्स - 2 40 100 3 7

यहां छवि विवरण दर्ज करें


क्या rआपके सभी उदाहरणों में वास्तव में 50 है? इसका मतलब होगा कि रोलर लगभग 50 बार जाता है।
केल्विन के शौक

@ केल्विन हॉबीज का नया उदाहरण पीआई 3 दर्शाता है
स्ट्रेच

1
@StretchManiac यह सही नहीं हो सकता। 3 आपको स्थिर बहुभुज के चारों ओर 9 बार से थोड़ा अधिक ले जाना चाहिए।
मार्टिन एंडर

4
यह मज़ेदार है कि क्लास का नाम RotatingPolygonsGolfed"गोल्फ" कोड में है जबकि यह RotatingPolygonsसामान्य कोड में है। ;)
केल्विन के शौक

1
आप वर्णों का एक अच्छा हिस्सा सिर्फ विशिष्ट वर्गों के बजाय * का उपयोग करने के लिए अपने आयात को बदलकर बचा सकते हैं ...
छद्मनाम 11

12

जावास्क्रिप्ट, 1284 चार्ट (-200 = 1084 चार्ट)

न्यूनतम कोड है

function epi(B,r2,r1,n2,n1){K=Math;function C(t){return K.cos(t)}function S(t){return K.sin(t)}function A(y,x){return K.atan2(y,x)}P=K.PI;v=[[],[]];w=[[],[]];z=[];function Z(x,y,j){c=C(t=f*H+P/2);s=S(t);v[j][n]=c*x-s*y;w[j][n]=s*x+c*y;}function E(i){return{x:r1*S(t=p-i*q),y:r1*C(t)};}function D(x,y,X,Y,t){L=A(m.y,m.x);M=K.sqrt(m.x*m.x+m.y*m.y);N=K.sqrt(X*X+Y*Y);O=~~(t*(M>N?M:N)+1);for(i=J;i<=O;i++){J=1;z[n]=f*H+P+t*i/O;Z(x+M*C(T=L+t*i/O),y+M*S(T),0);Z(x+N*C(T=A(Y,X)+t*i/O),y+N*S(T),1);n++}}function F(x,y,n,r,L,s){I.strokeStyle=s;I.beginPath();for(i=0;i<n;i++)I[i?'lineTo':'moveTo'](x+r*C(t=L+(1-2*i)*P/n),y+r*S(t)*W);I.closePath();I.stroke()}p=P/n1;q=2*p;u=P/n2;H=2*u;s2=r2*S(u);g=f=l=n=J=h=0;R=300;while(l<=(B*2+1)*P/H){o=E(0);m=E(h);m.y-=o.y;m.x-=o.x;if(g<s2){D(g,-r2*C(u),-o.x,-o.y,q);h=(h+1)%n1;g+=2*r1*S(p)}else{m.x+=g-s2;D(s2,-r2*C(u),-o.x+g-s2,-o.y,H);g-=s2*2;f=(f+1)%n2;l++}}return function(e_,t,aa,W_){W=aa?-1:1;I=(e=e_).getContext('2d');I.fillStyle='black';I.fillRect(0,0,600,600);W_&1&&F(R,R,n2,r2,0,'white');T=A(w[1][0],v[1][0]);U=V=0;I.strokeStyle='teal';I.beginPath();I.moveTo(R+v[0][0],R+w[0][0]*W);while(U<t){_=A(w[1][V+1],v[1][V+1]);U+=_-T+(_+1<T?2*P:0);T=_;V++;I.lineTo(R+v[0][V],R+w[0][V]*W)}W_&2&&I.stroke();W_&4&&F(R+v[1][V],R+w[1][V]*W,n1,r1,z[V],'red')}}

पूर्ण कोड है

function epi( nr, r2, r1, n2, n1 ) {
function C( t )
    { return Math.cos( t ); }
function S( t )
    { return Math.sin( t ); }
function A( dy, dx )
    { return Math.atan2( dy, dx ); }

var iCCW, e, t_, xs = [[],[]], ys = [[],[]], ts = [], n = 0, iArc0 = 0;

function addpt( x, y, iBin ) {
    var c_ = C(t_ = iFrame*t2 + Math.PI/2 ),
        s_ = S(t_);

    xs[iBin][n] = c_*x-s_*y;
    ys[iBin][n] = s_*x+c_*y;
}

function poly1pt( iP )
    { return { x: r1*S(t_ = t1b2-iP*t1), y: r1*C(t_) }; }

function arc1( P_Arc_, xP_, yP_, xC_, yC_, t ) {
    var dx_, dy_, dxC, dyC;
    var t0 = A( dy_ = P_Arc_.y, dx_ = P_Arc_.x ),
        r_ = Math.sqrt( dx_*dx_ + dy_*dy_ ),
        t0C = A( dyC = yC_, dxC = xC_ ),
        rC = Math.sqrt( dxC*dxC + dyC*dyC ),
        nt = ~~(t*(r_>rC?r_:rC)+1);

    for( var i = iArc0; i <= nt; i++ ) {
        iArc0 = 1;
        ts[n] = iFrame*t2 + Math.PI + t*i/nt;
        addpt( xP_ + r_*C(t_ = t0+t*i/nt), yP_ + r_*S(t_), 0 );
        addpt( xP_ + rC*C(t_ = t0C+t*i/nt), yP_ + rC*S(t_), 1 );
        n++;
    }
}

function poly( x,y, n, r, t0, sColor ) {
    var Cx = e.getContext('2d');
    Cx.strokeStyle = sColor;
    Cx.beginPath();
    for( var i = 0; i < n; i++ )
        Cx[i ? 'lineTo' : 'moveTo']( x + r*C(t_ = t0+(1-2*i)*Math.PI/n), y + r*S(t_)*iCCW );

    Cx.closePath();
    Cx.stroke();
}

var t1b2 = Math.PI/n1,
    t1 = 2*t1b2,
    t2b2 = Math.PI/n2,
    t2 = 2*t2b2,
    s1 = 2*r1*S(t1b2),
    s2 = 2*r2*S(t2b2),
    xPivot = 0,
    iPivot = 0,
    iFrame = 0,
    P_Pivot, P_Arc,
    nFrame = 0;

while( nFrame <= (nr*2+1)*Math.PI/t2 ) {
    P_Pivot = poly1pt( 0 );
    P_Arc = poly1pt( iPivot );
    if( xPivot < s2/2 ) {
        P_Arc.x -= P_Pivot.x;
        P_Arc.y -= P_Pivot.y;
        arc1( P_Arc, xPivot, -r2*C(t2b2), -P_Pivot.x, -P_Pivot.y, t1 );
        iPivot = (iPivot+1) %n1;
        xPivot += s1;
    } else {
        P_Arc.x -= (P_Pivot.x - (xPivot - s2/2));
        P_Arc.y -= P_Pivot.y;
        arc1( P_Arc, s2/2, -r2*C(t2b2), -P_Pivot.x + xPivot - s2/2, -P_Pivot.y, t2 );
        xPivot -= s2;
        iFrame = (iFrame+1) %n2;
        nFrame++;
    }
}

function renderTo( eCanvas, t, isCCW, sWhat ) {
    iCCW = isCCW ? -1 : 1;
    var Cx = (e = eCanvas).getContext('2d');
    Cx.fillStyle = 'black';
    Cx.fillRect( 0,0, 600,600 );

    if( sWhat &1 )
        poly( 300,300, n2, r2, 0, 'white' );

    var tRef = A( ys[1][0], xs[1][0] ),
        tCum = 0,
        i0 = 0;

    Cx.strokeStyle = 'green';
    Cx.beginPath();
    Cx.moveTo( 300+xs[0][0], 300+ys[0][0]*iCCW );
    while( tCum < t ) {
        t_ = A( ys[1][i0+1], xs[1][i0+1] );
        tCum += t_ - tRef + (t_ - tRef < -1 ? 2*Math.PI : 0);
        tRef = t_;
        i0++;
        Cx.lineTo( 300+xs[0][i0], 300+ys[0][i0]*iCCW );
    }
    if( sWhat &2 )
        Cx.stroke();
    if( sWhat &4 )
        poly( 300+xs[1][i0], 300+ys[1][i0]*iCCW, n1, r1, ts[i0], 'red' );
}

return renderTo;
}

अपनी सभी बहुभुज महिमा (और एनीमेशन प्रदर्शित करने के लिए) में दिनचर्या को निहारने के लिए एक बेला मिला है

http://jsfiddle.net/7rv751jy/2/embedded/result/

स्क्रिप्ट एक फ़ंक्शन को परिभाषित करती है जिसे epiओपी में पांच सूचीबद्ध मापदंडों को स्वीकार किया जाता है। epiहस्ताक्षर के साथ एक फ़ंक्शन देता है (e,t,isCCW,flags)जो तर्क स्वीकार करता है:

  • e - एक 600x600 HTML5 कैनवास तत्व का संदर्भ जिस पर रेंडर करना है
  • t- कुल कोण (रेडियन में) कि दूसरे बहुभुज का केन्द्रक पहले के केन्द्रक के आसपास स्वीप करना चाहिए। पास किए गए घुमावों की संख्या से तर्क 2 पीआई गुना से अधिक नहीं होना चाहिए epi
  • isCCW - बूलियन यह दर्शाता है कि क्या ट्रेसकॉलवाइज दिशा में आगे बढ़ना चाहिए (एक दक्षिणावर्त के विपरीत)
  • flags - बिट झंडे का एक सेट जो दर्शाता है कि किन तत्वों का प्रतिपादन किया जाना चाहिए
    • बिट 1 - सेट होने पर बहुभुज 1 प्रस्तुत करें
    • बिट 2 - ट्रेस सेट अगर प्रस्तुत करना
    • बिट 3 - सेट होने पर बहुभुज 2 को प्रस्तुत करें

समारोह को तर्कों के अलग-अलग सेटों के साथ किसी भी समय कहा जा सकता है।

कुछ नोट:

  • दिनचर्या पतित मामलों को संभालती है जहां n1 = 2और / या n2 = 2। जब एनिमेटिंग, लंबाई के कुछ संयोजनों से ट्रेस में अचानक तेजी से वृद्धि होगी। इसका कारण यह है कि एनीमेशन फ्रेम को दूसरे बहुभुज के केन्द्रक पर कोण द्वारा अनुक्रमित किया जाता है, और dta poly2 / d थीटा केन्द्रक उन मामलों में विलक्षण हो जाता है जहाँ 2-पक्षीय पाली 2 का केन्द्रक 2-पक्षीय पाली 1 के शीर्ष के पास होता है , हालांकि यह ट्रेस को प्रभावित नहीं करता है।

  • epiपूरे विकास के बाद से पैरामीटर के नाम भ्रामक प्रतीत होंगे, मैंने बहुभुज 1 को "2", और बहुभुज 2 को "1" कहा। जब मुझे अपने अधिवेशन और ओपी के बीच असंगतता का एहसास हुआ, तो कोड में सभी सूचकांकों की अदला-बदली करने के बजाय, मैंने बस तर्कों के क्रम में अदला-बदली की epi

  • आयात jQuery ऊपर fiddle, लेकिन यह यूआई को संभालने के लिए है। epiसमारोह कोई पुस्तकालय निर्भरता है।

  • कोड बस Y अक्ष को हटाकर CCW निशान को संभालता है। यह कुछ हद तक असंगत है क्योंकि बहुभुज 2 CCW निशान के दौरान वाई-उल्टे स्थिति में शुरू होता है, लेकिन किसी ने नहीं कहा कि दिनचर्या सुरुचिपूर्ण होनी चाहिए। ;)


1
सुंदर! मैंने पाया है कि फुलस्क्रीन लिंक के साथ काम करना सबसे आसान है: jsfiddle.net/7rv751jy/embedded/result
केल्विन के शौक

एक छोटी सी शिकायत यह है कि ट्रेसर वर्टेक्स डो एक स्थिर शिखर पर शुरू नहीं होता है।
केल्विन के शौक

हा। मैंने पूरी तरह से अनदेखी की कि ऐनक में। मैं 'हा' कहता हूं क्योंकि कोड मूल रूप से (अनजाने में) कल्पना करने के लिए था, लेकिन मैंने ट्रेस वर्टेक्स को बदल दिया क्योंकि मुझे लगा कि ट्रेस तुरंत बेहतर लगेगा अगर यह तुरंत शुरू हो गया। मैंने कोड को अपडेट कर दिया है ताकि यह कल्पना कर सके, और फिडेल के लिंक को एक फुलस्क्रीन कल्पना-अनुरूप संस्करण में अपडेट किया। एक बोनस के रूप में, यह कुल गिनती से एक वर्ण को खटखटाता है।
सीओटीओ

मैं इसे थोड़ा कैसे गति कर सकता हूं? जेएस नोब यहाँ।
सोहम चौधरी

@SohamChowdhury: कोड nt = ~~(t*(r_>rC?r_:rC)+1)को बदलें nt = ~~(t*(r_>rC?r_:rC)/10+1)और इसे चीजों को थोड़ा तेज करना चाहिए।
COTO
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.