2016-02-26 13 views
13

जैसा कि मेरे पिछले approach काम नहीं कर रहा है और एक समाधान जटिल होगा, मैंने एक और दृष्टिकोण आज़माने का फैसला किया है जो थोड़ा सा सरल हो सकता है।हेक्सागोन (विभिन्न दृष्टिकोण) के साथ सर्कल भरना

इस बार, कोड किसी हेक्सागोन को खींचने से पहले, यह निर्धारित करना होगा कि पूर्व परिभाषित सर्कल में कितनी पंक्तियां और कॉलम फिट हो सकते हैं और इस परिणाम के आधार पर यह सभी हेक्सागोन को चित्रित करना शुरू कर देता है।

अभी तक यह काम करता है, लेकिन जैसा कि मेरे पिछले दृष्टिकोण में, ऐसे समय होते हैं जब हेक्स ओवरलैपिंग होते हैं, या सर्कल के निचले भाग में एक बड़ा अंतर छोड़ते हैं।

एक और चिंता यह है कि, मैं इन हेक्सागोन को ग्रिड में कैसे प्रारूपित करूं?

नोट, कैनवास के नीचे एक छोटा स्लाइडर है, जो आपको सर्कल के त्रिज्या को बढ़ाने/घटाने और हेक्सागोन को फिर से निकालने देता है।

var c_el = document.getElementById("myCanvas"); 
 
var ctx = c_el.getContext("2d"); 
 

 
var canvas_width = c_el.clientWidth; 
 
var canvas_height = c_el.clientHeight; 
 
var circle = { 
 
\t r: 120, /// radius 
 
\t pos: { 
 
\t \t x: (canvas_width/2), 
 
\t \t y: (canvas_height/2) 
 
\t } 
 
} 
 

 
var hexagon = { 
 
\t r: 20, 
 
\t pos:{ 
 
\t \t x: 0, 
 
\t \t y: 0 
 
\t } 
 
} 
 

 
var hex_w = hexagon.r * 2; 
 
var hex_h = Math.floor(Math.sqrt(3) * hexagon.r); 
 
var hex_s = (3/2) * hexagon.r; 
 

 
fill_CircleWithHex(circle); 
 

 
function fill_CircleWithHex(circle){ 
 
\t drawCircle(circle); 
 
\t 
 
\t var c_h = circle.r * 2; /// circle height //// 
 
\t var c_w = c_h; //// circle width ///// 
 
\t 
 
\t var max_hex_H = Math.round(c_h/hex_h); 
 
\t 
 
\t var row_sizes = [] 
 
\t for(var row= 0; row< max_hex_H; row++){ 
 
\t \t 
 
\t \t var d = circle.r - (row* hex_h); //// distance from circle's center to the row's chord //// 
 
\t \t var c = 2 * (Math.sqrt((circle.r*circle.r) - (d * d))); /// length of the row's chord //// 
 
\t \t var row_length = Math.floor(c/(hexagon.r * 3)); 
 
\t \t row_sizes.push(row_length ) 
 
\t } 
 
\t 
 
\t console.log("circle_r : "+circle.r); 
 
\t console.log("hex_r : "+hexagon.r); 
 
\t console.log("max_hex_H : "+max_hex_H); 
 
\t console.log("max_hex_W : ", row_sizes) 
 

 
\t for(var row = 0; row < row_sizes.length; row++){ 
 
\t \t var max_hex_W = row_sizes[row]; 
 
\t \t 
 
\t \t var x_offset = Math.floor((c_w - (max_hex_W * hex_w))/2); 
 
\t \t 
 
\t \t for(var col = 1; col < max_hex_W; col++){ 
 
\t \t \t hexagon.pos.x = (col * hex_w) + (circle.pos.x - circle.r) + x_offset ; 
 
\t \t \t hexagon.pos.y = (row * hex_h) + (circle.pos.y - circle.r); 
 
\t \t \t ctx.fillText(row+""+col, hexagon.pos.x - 6, hexagon.pos.y+4); 
 
\t \t \t drawHexagon(hexagon) 
 
\t \t } 
 
\t } 
 
} 
 

 
function drawHexagon(hex){ 
 
\t var angle_deg, angle_rad, cor_x, cor_y; 
 
\t ctx.beginPath(); 
 
\t for(var c=0; c <= 5; c++){ 
 
\t \t angle_deg = 60 * c; 
 
\t \t angle_rad = (Math.PI/180) * angle_deg; 
 
\t \t cor_x = hex.r * Math.cos(angle_rad); //// corner_x /// 
 
\t \t cor_y = hex.r* Math.sin(angle_rad); //// corner_y /// 
 
\t \t if(c === 0){ 
 
\t \t \t ctx.moveTo(hex.pos.x+ cor_x, hex.pos.y+cor_y); 
 
\t \t }else{ 
 
\t \t \t ctx.lineTo(hex.pos.x+cor_x, hex.pos.y+cor_y); 
 
\t \t } 
 
\t } 
 
\t ctx.closePath(); 
 
\t ctx.stroke(); 
 
} 
 

 
function drawCircle(circle){ 
 
\t ctx.beginPath(); 
 
\t ctx.arc(circle.pos.x, circle.pos.y, circle.r, 0, 2 * Math.PI); 
 
\t ctx.stroke(); 
 
} 
 

 

 
    $(function() { 
 
    $("#slider").slider({ 
 
\t \t max: 200, 
 
\t \t min:0, 
 
\t \t value:100, 
 
\t \t create: function(event, ui) { 
 
\t \t \t $("#value").html($(this).slider('value')); 
 
\t \t }, 
 
\t \t change: function(event, ui) { 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t }, 
 
\t \t slide: function(event, ui){ 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t \t circle.r = ui.value; 
 
\t \t \t ctx.clearRect(0,0, canvas_width, canvas_height); 
 
\t \t \t fill_CircleWithHex(circle); 
 
\t \t } 
 
\t }); 
 
    });
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> 
 
<link href="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.css" rel="stylesheet"/> 
 
<script src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js"></script> 
 

 
<canvas id="myCanvas" width="350" height="250" style="border:1px solid #d3d3d3;"> </canvas> 
 
<div style="width: 200px; height: 40px;"> 
 
\t <div id="slider" style="position:relative; width: 150px; top: 4px;float: left;"></div> <div id="value" style="float: left;"> 0 </div> 
 
</div>

+0

मैं उलझन में हूं। क्या हेक्सागोन और सर्कल दोनों के आकार दिए गए हैं? क्या आप समस्या को और अधिक सटीक बता सकते हैं? कठोर बाधाएं क्या हैं और आप अधिकतम करने की क्या कोशिश कर रहे हैं। –

+0

हार्ड बाधा सर्कल का आकार है, इस पर आधारित षट्भुज ग्रिड उत्पन्न किया जा रहा है। – Alexus

+0

क्या इसे सिर्फ हेक्सागोन पैटर्न की तरह दिखना है? हेक्सागोन को गिना जाना है? मैं हेक्सागोन शैली उत्पन्न करने के लिए बस स्मार्ट सीएसएस पृष्ठभूमि को लागू करने की सोच रहा हूं। – Paul

उत्तर

6

निम्नलिखित एक नियमित मधुकोश संरचना चक्र के मध्य पर केंद्रित के लिए पैकिंग समस्या का हल। नियमित माध्यम:

  • सभी हेक्सागोन का सेट सर्कल के केंद्र के चारों ओर 60 डिग्री घूर्णन के नीचे सममित है।

व्यक्तिगत हेक्सागोन के निर्देशांक केंद्र से काउंटर हेक्सागोन खोल की सामान्य संख्या और उच्च दोपहर से शुरू होने वाले घड़ी के अनुक्रम संख्या का प्रतिनिधित्व करते हैं।

जैसे सर्कल चौड़ा होता है, नए हेक्सागोन गोले पूरी तरह से भर नहीं जाते हैं। हालांकि बाहरी खोल को भरने की आजादी की डिग्री आंशिक रूप से एक बेहतर समाधान उत्पन्न करती है, फिर भी यह इष्टतम नहीं है। घूर्णन समरूपता के लिए नियमितता को आराम से 60 डिग्री (अर्थात् 120 और 180 डिग्री) से दूसरे कोणों को घुमाएं, सर्कल के इंटीरियर के उच्च कवरेज की अनुमति देंगे।

मैं इस कोड के अगले संशोधन के लिए इसके पीछे गणित को देखूंगा (और सर्कल के आसपास घूर्णन समरूपता साबित करने के लिए प्रमेय को संभवतः इष्टतमता के लिए एक आवश्यक शर्त है)।

var c_el; 
 
var ctx; 
 
var canvas_width; 
 
var canvas_height; 
 
var circle; 
 
var hexagon; 
 
var hex_w; 
 
var hex_h; 
 
var hex_s; 
 
var delta; 
 

 
function drawHexagonAt (po_ctr_hex, pn_circle, pn_sector) { 
 
    var cur 
 
     ; 
 
     
 
    cur = { x: po_ctr_hex.x - 0.5 * hexagon.r, y: po_ctr_hex.y - delta }; 
 
    
 
    ctx.beginPath(); 
 
    ctx.moveTo(cur.x, cur.y); 
 
    cur.x = cur.x + hexagon.r; 
 
    cur.y = cur.y; 
 
    ctx.lineTo(cur.x, cur.y); 
 
    cur.x = cur.x + hexagon.r/2; 
 
    cur.y = cur.y + delta; 
 
    ctx.lineTo(cur.x, cur.y); 
 
    cur.x = cur.x - hexagon.r/2; 
 
    cur.y = cur.y + delta; 
 
    ctx.lineTo(cur.x, cur.y); 
 
    cur.x = cur.x - hexagon.r; 
 
    cur.y = cur.y; 
 
    ctx.lineTo(cur.x, cur.y); 
 
    cur.x = cur.x - hexagon.r/2; 
 
    cur.y = cur.y - delta; 
 
    ctx.lineTo(cur.x, cur.y); 
 
    cur.x = cur.x + hexagon.r/2; 
 
    cur.y = cur.y - delta; 
 
    ctx.lineTo(cur.x, cur.y); 
 
\t ctx.closePath(); 
 
\t ctx.stroke(); 
 

 
    cur.x = cur.x + hexagon.r/2; 
 
    cur.y = cur.y + delta; 
 
\t ctx.fillText(pn_circle + "/" + pn_sector, cur.x-6, cur.y+4); 
 
} // drawHexagonAt 
 

 
function fill_CircleWithHex(circle){ 
 
\t drawCircle(circle); 
 
\t 
 
\t var radacc2; 
 
\t var iter = 0; 
 
\t var sector = 0; 
 
\t var i, j; 
 
\t var ctr  = { x: circle.pos.x , y: circle.pos.y }; 
 
\t var cur  = { x: 0   , y: 0 }; 
 
\t 
 
\t delta = Math.floor(Math.sqrt(3) * 0.5 * hexagon.r); 
 
    radacc2 = hexagon.r * hexagon.r; 
 
\t while ((radacc2 < circle.r * circle.r)) { 
 
\t  cur.x = ctr.x; 
 
\t  cur.y = ctr.y - iter * 2 * delta; 
 
\t  
 
\t  if (iter === 0) { 
 
\t   drawHexagonAt (cur, 0, 0); 
 
\t  } 
 
\t  else { 
 
    \t  for (var i=0; i < 6; i++) { 
 
    \t   // j-loops -- next honeycomb 
 
    \t   sector = 0; 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x + 1.5 * hexagon.r; 
 
    \t    cur.y = cur.y + delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x; 
 
    \t    cur.y = cur.y + 2 * delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x - 1.5 * hexagon.r; 
 
    \t    cur.y = cur.y + delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x - 1.5 * hexagon.r; 
 
    \t    cur.y = cur.y - delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x; 
 
    \t    cur.y = cur.y - 2 * delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t   for (var j=0; j < iter; j++) { 
 
    \t    cur.x = cur.x + 1.5 * hexagon.r; 
 
    \t    cur.y = cur.y - delta; 
 
    \t    drawHexagonAt (cur, iter, sector++); 
 
    \t   } 
 
    \t  } // i-loop -- meta-honeycomb 
 
    \t } // if -- Iteration 1 vs. n > 1 
 
    \t  
 
    \t  // radacc update 
 
    \t  iter++; 
 
     radacc2 = ((2*iter + 1) * delta) * ((2*iter + 1) * delta) + hexagon.r * hexagon.r/4; 
 
    } // while -- komplette Shells 
 
    
 
    // 
 
    // Partielle Shells 
 
    // 
 
    var proceed; 
 
    do { 
 
\t  cur.x = ctr.x; 
 
\t  cur.y = ctr.y - iter * 2 * delta; 
 
     proceed = false; 
 

 
\t  for (var i=0; i < 6; i++) { 
 
\t   // j-loops -- next honeycomb 
 
\t   sector = 0; 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x + 1.5 * hexagon.r; 
 
\t    cur.y = cur.y + delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x; 
 
\t    cur.y = cur.y + 2 * delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x - 1.5 * hexagon.r; 
 
\t    cur.y = cur.y + delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x - 1.5 * hexagon.r; 
 
\t    cur.y = cur.y - delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x; 
 
\t    cur.y = cur.y - 2 * delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t   for (var j=0; j < iter; j++) { 
 
\t    cur.x = cur.x + 1.5 * hexagon.r; 
 
\t    cur.y = cur.y - delta; 
 
\t    sector++ 
 
\t    if (Math.sqrt ((cur.x - ctr.x) * (cur.x - ctr.x) + (cur.y - ctr.y) * (cur.y - ctr.y)) + hexagon.r < circle.r) { 
 
\t     drawHexagonAt (cur, iter, sector); 
 
\t     proceed = true; 
 
\t    } 
 
\t   } 
 
\t  } // i-loop -- meta-honeycomb 
 
\t  
 
\t  iter++; 
 
    } while (proceed && (iter < 15));  
 
    
 
} // fill_CircleWithHex 
 

 

 
function drawCircle(circle){ 
 
\t ctx.beginPath(); 
 
\t ctx.arc(circle.pos.x, circle.pos.y, circle.r, 0, 2 * Math.PI); 
 
\t ctx.stroke(); 
 
} 
 

 

 
    $(function() { 
 
    $("#slider").slider({ 
 
\t \t max: 200, 
 
\t \t min:0, 
 
\t \t value:100, 
 
\t \t create: function(event, ui) { 
 
\t \t \t $("#value").html($(this).slider('value')); 
 
\t \t }, 
 
\t \t change: function(event, ui) { 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t }, 
 
\t \t slide: function(event, ui){ 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t \t circle.r = ui.value; 
 
\t \t \t ctx.clearRect(0,0, canvas_width, canvas_height); 
 
\t \t \t fill_CircleWithHex(circle); 
 
\t \t } 
 
\t }); 
 
    }); 
 
    
 
$(document).ready(function() { 
 
    c_el = document.getElementById("myCanvas"); 
 
    ctx = c_el.getContext("2d"); 
 
    
 
    canvas_width = c_el.clientWidth; 
 
    canvas_height = c_el.clientHeight; 
 

 
    circle = { 
 
    \t r: 120, /// radius 
 
    \t pos: { 
 
    \t \t x: (canvas_width/2), 
 
    \t \t y: (canvas_height/2) 
 
    \t } 
 
    }; 
 
    
 
    hexagon = { 
 
    \t r: 20, 
 
    \t pos:{ 
 
    \t \t x: 0, 
 
    \t \t y: 0 
 
    \t } 
 
    }; 
 
    
 
    hex_w = hexagon.r * 2; 
 
    hex_h = Math.floor(Math.sqrt(3) * hexagon.r); 
 
    hex_s = (3/2) * hexagon.r; 
 
    
 
    fill_CircleWithHex(circle); 
 
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> 
 
<link href="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.css" rel="stylesheet"/> 
 
<script src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js"></script> 
 

 
<canvas id="myCanvas" width="350" height="250" style="border:1px solid #d3d3d3;"> </canvas> 
 
<div style="width: 200px; height: 40px;"> 
 
<div id="slider" style="position:relative; width: 150px; top: 4px;float: left;"></div> <div id="value" style="float: left;"> 0 </div> 
 
</div>

+0

अब तक का सबसे अच्छा जवाब है, हालांकि इसकी तुलना में यह अधिक जटिल है .. क्या इसे थोड़ा सा सरल बनाना संभव होगा? (मैं उपरोक्त आपके उदाहरण में उपयोग की जाने वाली लूपों की मात्रा का जिक्र कर रहा हूं।) – Alexus

+0

अगले 6 हेक्सागोन के मध्य बिंदु की गणना को अलग करने के लिए 6 मामलों के साथ स्विच स्टेटमेंट के सीपीओस्ट पर सबसे कम 6 लूप को ध्वस्त किया जा सकता है। इसी तरह, आंशिक गोले के लिए कोड पहले लूप में ध्वस्त हो सकता है। हालांकि, वर्तमान में सबसे निचले हेक्सागोन का मध्यबिंदु और सर्कल हमेशा मेल खाता है। इससे आराम करने से अभी भी एक बेहतर समाधान की अनुमति मिलेगी, लेकिन कोड संरचना को शायद वैसे भी अनुकूलित करने की आवश्यकता है। मैं आज रात में देख लूंगा। – collapsar

+3

अच्छा काम। उन आंतरिक लूप को फ़ंक्शन कॉल में बदल सकते हैं: https://jsfiddle.net/7ekv24ab/ थोड़ा सा सरल करता है। – tiffon

0

हेक्स के पैक करने के लिए अपने कोड पर कुछ समय बिताया। यह सही नहीं है और मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है। यदि यह मदद करता है, तो इसे जांचें, या यदि आप सर्कल के हेक्स के चरणबद्ध चरण को ठीक कर सकते हैं [अब, row_sizes की गणना के साथ कोई समस्या है]। जब भी मुझे समय मिलता है, तो शायद मैं इसे फिर से देख सकता हूं, या हम इसे करने के अन्य तरीकों को देख सकते हैं।

var c_el = document.getElementById("myCanvas"); 
 
var ctx = c_el.getContext("2d"); 
 

 
var canvas_width = c_el.clientWidth; 
 
var canvas_height = c_el.clientHeight; 
 
var circle = { 
 
\t r: 120, /// radius 
 
\t pos: { 
 
\t \t x: (canvas_width/2), 
 
\t \t y: (canvas_height/2) 
 
\t } 
 
} 
 

 
var hexagon = { 
 
\t r: 20, 
 
\t pos:{ 
 
\t \t x: 0, 
 
\t \t y: 0 
 
\t } 
 
} 
 

 
var hex_w = hexagon.r * 3; /// added spacing 
 
var hex_h = Math.floor(Math.sqrt(3) * hexagon.r/2); /// added spacing 
 
var hex_s = (3/2) * hexagon.r; 
 

 
var hex_width = 33.4; //based on r = 20 
 

 
fill_CircleWithHex(circle); 
 

 
function fill_CircleWithHex(circle){ 
 
\t drawCircle(circle); 
 
\t 
 
\t var c_h = circle.r * 2; /// circle height //// 
 
\t var c_w = c_h; //// circle width ///// 
 

 
\t var max_hex_H = Math.round(c_h/(hex_h )); 
 
\t var row_sizes = [] 
 
    
 
\t for(var col= 0; col < max_hex_H; col++){ 
 
\t \t 
 
\t \t var d = circle.r - (col * hex_h); //// distance from circle's center to the row's chord //// 
 
\t \t var c = 2 * (Math.sqrt((circle.r*circle.r) - (d * d))); /// length of the row's chord //// 
 
\t \t 
 
\t \t row_sizes.push(Math.ceil(c/(hexagon.r * 3))) 
 
\t } 
 

 
\t for(var row = 0; row < row_sizes.length; row++){ 
 
\t \t var max_hex_W = row_sizes[row]; 
 
    console.log(hex_w); 
 
\t \t var x_offset = Math.floor((c_w - (max_hex_W * hex_w))) + row%2 * hex_width - hex_width/2; // changed offset to define a zig zag 
 
\t \t 
 
\t \t for(var col = 1; col < max_hex_W; col++){ 
 
\t \t \t hexagon.pos.x = (col * hex_w) + (circle.pos.x - circle.r) + x_offset ; 
 
\t \t \t hexagon.pos.y = (row * 17.3) + (circle.pos.y - circle.r) ; 
 
\t \t \t ctx.fillText(row+""+col, hexagon.pos.x - 6, hexagon.pos.y+4); 
 
\t \t \t drawHexagon(hexagon) 
 
\t \t } 
 
\t } 
 
} 
 

 
function drawHexagon(hex){ 
 
\t var angle_deg, angle_rad, cor_x, cor_y; 
 
\t ctx.beginPath(); 
 
    
 
\t for(var c=0; c <= 5; c++){ 
 
\t \t angle_deg = 60 * c; 
 
\t \t angle_rad = (Math.PI/180) * angle_deg; 
 
\t \t cor_x = hex.r * Math.cos(angle_rad); //// corner_x /// 
 
\t \t cor_y = hex.r* Math.sin(angle_rad); //// corner_y /// 
 
\t \t if(c === 0){ 
 
\t \t \t ctx.moveTo(hex.pos.x+ cor_x, hex.pos.y+cor_y); 
 
\t \t }else{ 
 
\t \t \t ctx.lineTo(hex.pos.x+cor_x, hex.pos.y+cor_y); 
 
\t \t } 
 
\t } 
 
\t ctx.closePath(); 
 
\t ctx.stroke(); 
 
} 
 

 
function drawCircle(circle){ 
 
\t ctx.beginPath(); 
 
\t ctx.arc(circle.pos.x, circle.pos.y, circle.r, 0, 2 * Math.PI); 
 
\t ctx.stroke(); 
 
} 
 

 

 
    $(function() { 
 
    $("#slider").slider({ 
 
\t \t max: 200, 
 
\t \t min:0, 
 
\t \t value:100, 
 
\t \t create: function(event, ui) { 
 
\t \t \t $("#value").html($(this).slider('value')); 
 
\t \t }, 
 
\t \t change: function(event, ui) { 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t }, 
 
\t \t slide: function(event, ui){ 
 
\t \t \t $("#value").html(ui.value); 
 
\t \t \t circle.r = ui.value; 
 
\t \t \t ctx.clearRect(0,0, canvas_width, canvas_height); 
 
\t \t \t fill_CircleWithHex(circle); 
 
\t \t } 
 
\t }); 
 
    });
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> 
 
<link href="https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.css" rel="stylesheet"/> 
 
<script src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js"></script> 
 

 
<canvas id="myCanvas" width="350" height="250" style="border:1px solid #d3d3d3;"> </canvas> 
 
<div style="width: 200px; height: 40px;"> 
 
\t <div id="slider" style="position:relative; width: 150px; top: 4px;float: left;"></div> <div id="value" style="float: left;"> 0 </div> 
 
</div>

+0

डाउनवॉटेड क्योंकि आपका समाधान रोकथाम की बाधा का उल्लंघन करता है। – collapsar

0

संक्षिप्त उत्तर: वहाँ यह करने के लिए कोई आसान तरीका है। आपके पास बहुत से विशेष मामले हैं। यह स्पष्ट करने के लिए, 1, 2, 3, 4, 6 और 7 हेक्सागोन के साथ सरल प्रारंभ करें, उन न्यूनतम सर्कल को खींचें जो उनके ऊपर फिट होंगी, और ध्यान दें कि सर्कल का केंद्र समाप्त होता है।

जैसा कि आप देख सकते हैं कि सर्कल का केंद्र काफी हद तक चलता है।यह एक षट्भुज या जंक्शन पर, हेक्सागोन के बीच में समाप्त हो सकता है।

तब से यह केवल खराब हो जाता है।

इस समस्या पर सबसे नज़दीक मुझे मिल सकता है this page है।

संपादित करें: आप प्रोग्रामिंग में हेक्सागोन पर एक बहुत व्यापक उपचार के लिए निम्न ब्लॉग पेज देखना चाह सकते हैं।

http://www.redblobgames.com/grids/hexagons/

संबंधित मुद्दे