math - त्रिभुज/हेक्सागोनल निर्देशांक उत्पन्न करना(xyz)




coordinates vector (3)

एक और संभावित समाधान, जो ओ (त्रिज्या 2 ) में चलता है , टीएचमिक के समाधान (बहुत सी शैली के खर्च पर ) के ओ (त्रिज्या 4 ) के विपरीत यह है:

radius = 4
for r in range(radius):
    print "radius %d" % r
    x = 0
    y = -r
    z = +r
    print x,y,z
    for i in range(r):
        x = x+1
        z = z-1
        print x,y,z
    for i in range(r):
        y = y+1
        z = z-1
        print x,y,z
    for i in range(r):
        x = x-1
        y = y+1
        print x,y,z
    for i in range(r):
        x = x-1
        z = z+1
        print x,y,z
    for i in range(r):
        y = y-1
        z = z+1
        print x,y,z
    for i in range(r-1):
        x = x+1
        y = y-1
        print x,y,z

या संक्षेप में थोड़ा और लिखा है:

radius = 4
deltas = [[1,0,-1],[0,1,-1],[-1,1,0],[-1,0,1],[0,-1,1],[1,-1,0]]
for r in range(radius):
    print "radius %d" % r
    x = 0
    y = -r
    z = +r
    print x,y,z
    for j in range(6):
        if j==5:
            num_of_hexas_in_edge = r-1
        else:
            num_of_hexas_in_edge = r
        for i in range(num_of_hexas_in_edge):
            x = x+deltas[j][0]
            y = y+deltas[j][1]
            z = z+deltas[j][2]            
            print x,y,z

यह इस तथ्य से प्रेरित है कि हेक्सागोन वास्तव में हेक्सागोन के बाहरी हिस्से में हैं, इसलिए आप इसके 1 बिंदुओं के निर्देशांक पा सकते हैं, और उसके बाद 6 किनारों पर चलकर दूसरों की गणना कर सकते हैं।

मैं एक पुनरावृत्ति समारोह के साथ आने की कोशिश कर रहा हूं जो हेक्सागोनल ग्रिड के लिए xyz निर्देशांक उत्पन्न करता है। प्रारंभिक हेक्स स्थिति (सादगी के लिए 0,0,0 कहें) के साथ, मैं यहां वर्णित हेक्सागोन की प्रत्येक "अंगूठी" के लिए निर्देशांक की गणना करना चाहता हूं:

अब तक, मैं इसके साथ आने में कामयाब रहा हूं (जावास्क्रिप्ट में उदाहरण):

var radius = 3
var xyz = [0,0,0];

// for each ring
for (var i = 0; i < radius; i++) {
    var tpRing = i*6;
    var tpVect = tpRing/3;
    // for each vector of ring
    for (var j = 0; j < 3; j++) {
        // for each tile in vector
        for(var k = 0; k < tpVect; k++) {
            xyz[0] = ???;
            xyz[1] = ???;
            xyz[2] = ???;
            console.log(xyz);
        }
    }
}

मुझे पता है कि प्रत्येक अंगूठी में पिछले की तुलना में छह और अंक होते हैं और प्रत्येक 120 डिग्री वेक्टर में केंद्र से प्रत्येक चरण के लिए एक अतिरिक्त बिंदु होता है। मैं यह भी जानता हूं कि सभी टाइल्स के लिए x + y + z = 0 । लेकिन मैं नीचे दिए गए अनुक्रम का पालन करने वाले निर्देशांक की एक सूची कैसे उत्पन्न कर सकता हूं?

    0, 0, 0

    0,-1, 1
    1,-1, 0
    1, 0,-1
    0, 1,-1
   -1, 1, 0
   -1, 0, 1

    0,-2, 2
    1,-2, 1
    2,-2, 0
    2,-1,-1
    2, 0,-2
    1, 1,-2
    0, 2,-2
   -1, 2,-1
   -2, 2, 0
   -2, 1, 1
   -2, 0, 2
   -1,-1, 2

ठीक है, दोनों विकल्पों को आजमाने के बाद मैंने ऑफरी के समाधान पर बस गए हैं क्योंकि यह थोड़ा तेज़ है और प्रारंभिक ऑफसेट मूल्य प्रदान करना आसान बनाता है। मेरा कोड अब इस तरह दिखता है:

var xyz = [-2,2,0];
var radius = 16;
var deltas = [[1,0,-1],[0,1,-1],[-1,1,0],[-1,0,1],[0,-1,1],[1,-1,0]];
for(var i = 0; i < radius; i++) {
        var x = xyz[0];
        var y = xyz[1]-i;
        var z = xyz[2]+i;
        for(var j = 0; j < 6; j++) {
                for(var k = 0; k < i; k++) {
                        x = x+deltas[j][0]
                        y = y+deltas[j][1]
                        z = z+deltas[j][2]
                        placeTile([x,y,z]);
                }
        }
}

"PlaceTile" विधि एक पूर्वनिर्धारित svg तत्व की प्रतिलिपि बनाने के लिए क्लोन नोड का उपयोग करती है और इसे निष्पादित करने के लिए लगभग 0.5ms प्रति टाइल लगती है जो पर्याप्त से अधिक है। आपकी मदद के लिए tehMick और Ofri के लिए एक बड़ा धन्यवाद!

जे एस


यह एक मजेदार पहेली थी।

हे (त्रिज्या 2 ) लेकिन ऑफिस के समाधान की तुलना में (उम्मीद है) थोड़ा और शैली के साथ। यह मेरे लिए हुआ कि निर्देशांक उत्पन्न किए जा सकते थे जैसे कि आप एक दिशा (चाल) वेक्टर का उपयोग करके अंगूठी के चारों ओर "चलने" थे, और यह कि एक चाल बारी वेक्टर के चारों ओर शून्य स्थानांतरित करने के बराबर थी।

इस संस्करण को एरिक के समाधान पर भी लाभ है कि यह कभी भी अमान्य निर्देशांक पर छूता नहीं है (एरिक ने उन्हें अस्वीकार कर दिया है, लेकिन इसे कभी भी परीक्षण नहीं करना पड़ता है)।

# enumerate coords in rings 1..n-1; this doesn't work for the origin
for ring in range(1,4):
    # start in the upper right corner ...
    (x,y,z) = (0,-ring,ring)
    # ... moving clockwise (south-east, or +x,-z)
    move = [1,0,-1]         

    # each ring has six more coordinates than the last
    for i in range(6*ring):
        # print first to get the starting hex for this ring
        print "%d/%d: (%d,%d,%d) " % (ring,i,x,y,z)
        # then move to the next hex
        (x,y,z) = map(sum, zip((x,y,z), move))

        # when a coordinate has a zero in it, we're in a corner of
        # the ring, so we need to turn right
        if 0 in (x,y,z):
            # left shift the zero through the move vector for a
            # right turn
            i = move.index(0)
            (move[i-1],move[i]) = (move[i],move[i-1])

    print # blank line between rings

पायथन के अनुक्रम स्लाइसिंग के लिए तीन चीयर्स।





hexagonal-tiles