एक साधारण घन खींचें

Question

हमारे पास वास्तविक 3 आयामी घन खींचने के बारे में एक भी चुनौती नहीं है, इसलिए यहां यह दिया गया है:

चुनौती

आपका काम परिप्रेक्ष्य के साथ एक घुमाया हुआ क्यूब खींचना है। यह एक अलग विंडो में या एक छवि के रूप में हो सकता है।

इनपुट

आपका इनपुट 0 और 359.99 के बीच 3 अलग-अलग संख्याएं हैं ... ये डिग्री में x, y और z अक्ष के चारों ओर रोटेशन का प्रतिनिधित्व करते हैं।

0 0 0
30 0 40
95 320 12

उत्पादन

आप इसे एक अलग विंडो में प्रदर्शित कर सकते हैं या एक छवि को सहेज सकते हैं। आप किसी भी प्रकार के प्रदर्शन (वेक्टर आधारित, रेखापुंज आदि) का उपयोग कर सकते हैं।

संपादित करें: ASCII को केवल पाठ आउटपुट के साथ गोल्फिंग भाषाओं की अनुमति देने के लिए भी अनुमति दी गई है।

Rasterized या ASCII ग्राफिक्स के लिए आउटपुट कम से कम 50 * 50 होना चाहिए (Rasterization के लिए पिक्सेल, ASCII के लिए वर्ण)

अतिरिक्त जानकारी

सकारात्मक z अक्ष खिड़की से इंगित करता है, x अक्ष क्षैतिज है, और y अक्ष ऊर्ध्वाधर है। मूल रूप से ओपनजीएल मानक।

रोटेशन काउंटर-क्लॉकवाइज हैं यदि आप क्यूब को एक विशिष्ट अक्ष की नकारात्मक दिशा में देखते हैं, जैसे कि वाई अक्ष के लिए नीचे देख रहे हैं।

कैमरा नकारात्मक अक्ष दिशा में क्यूब से उचित दूरी पर z अक्ष पर होना चाहिए, क्यूब (0; 0; 0) पर होना चाहिए। । क्यूब को भी पूरी तरह से दिखाई देने की आवश्यकता है, और ड्राइंग फ्रेम का कम से कम 50% हिस्सा लें। कैमरे को क्यूब में पॉजिटिव z दिशा में देखना चाहिए।

घन के घूर्णन x-> y-> z क्रम में लागू होते हैं।

क्यूब को इसके केंद्र के चारों ओर घुमाया जाता है, यह स्थानांतरित नहीं होता है।

क्यूब को 2 डी स्पेस में प्रोजेक्ट करने के लिए, आपको क्यू और x के y निर्देशांक को बिंदु और कैमरे के बीच z- अक्ष के समानांतर दूरी के साथ विभाजित करने की आवश्यकता है।

नियम

रेंडरिंग लाइब्रेरी की अनुमति है, लेकिन कोड में वर्टिकल को परिभाषित करने की आवश्यकता है। कोई 3 डी क्यूब मॉडल वर्ग नहीं।

परीक्षण के मामलों

Comments

क्या इसे वायरफ्रेम होना चाहिए?

— R

अंक के लिए एक एल्गोरिथ्म शामिल करने की देखभाल?

— लीक नून

घूर्णन किस क्रम / दिशाओं में किया जाता है? कैमरा कहां से देख रहा है? हमें किस तरह के प्रक्षेपण का उपयोग करना है?

— त्रुटी

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

— त्रुटी

@ E @s muchIʀᴋ google will tell you the formula. नहीं , चुनौतियों में यथासंभव अधिक सामग्री और जानकारी होनी चाहिए, जो उन्हें हल करने के लिए आवश्यक हो, पोस्ट के शरीर में शामिल हैं । मुझे केवल समझ शुरू करने के लिए googling या Wikipedia-ing नहीं जाना चाहिए।

— बिल्ली

Answer 1

जूते (रूबी) 235 231

सब कुछ खरोंच से गणना की।

Shoes.app{p,a,b,c=ARGV.map{|j|j.to_f/90}
k=1+i="i".to_c
p=(0..3).map{|j|y,z=(k*i**(j+a)).rect
x,z=(((-1)**j+z*i)*i**b).rect
q=(x+y*i)*i**c
[90*(k+q/(z-4)),90*(k+q/(4+z))]}
4.upto(15){|j|line *(p[j%4][0].rect+p[(j+j/4)%4][1].rect)}}

कमांडलाइन जैसे से कॉल करें shoes cube3d.rb 0 30 0

यह विचार 3 डी में एक टेट्राहेड्रोन के चार शीर्षों को एक साथ उत्पन्न / घुमाने के लिए है। फिर, जैसा कि ये 2d तक कम हो जाते हैं, हम उलटा टेट्राहेड्रोन के चार कोने (कुल 8 कोने क्यूब के होते हैं।) उत्पन्न करते हैं। यह 4 बॉडी विकर्णों के अनुरूप 4 जोड़े देता है। अंत में 2d कोने रेखाओं से जुड़े होते हैं: मूल टेट्राहेड्रोन के प्रत्येक शीर्ष को व्युत्क्रम टेट्राहेड्रोन के प्रत्येक शीर्ष से जोड़ा जाना चाहिए, जिसमें 12 किनारों और घन के 4 शरीर विकर्ण होते हैं। आदेश सुनिश्चित करता है कि शरीर के विकर्णों को प्लॉट नहीं किया गया है।

परीक्षण के मामले उत्पादन

ध्यान दें, पिछले दो परीक्षण मामलों के अनुरूप होने के लिए, Z अक्ष के बारे में रोटेशन दर्शक के POV से दक्षिणावर्त है। हालांकि यह कल्पना के विपरीत है। रोटेशन दिशा को संशोधित करके बदला जा सकता है *i**c->/i**c

ungolfed

Shoes.app{
  p,a,b,c=ARGV.map{|j|j.to_f/90}   #Throw away first argument (script name) and translate next three to fractions of a right angle.
  k=1+i="i".to_c                   #set up constants i=sqrt(-1) and k=1+i

  p=(0..3).map{|j|                 #build an array p of 4 elements (each element wil be a 2-element array containing the ends of a body diagonal in complex number format)
    y,z=(k*i**(j+a)).rect          #generate 4 sides of square: 1+i,i-1,-1-i,-i+1, rotate about x axis by a, and store in y and z as reals 
    x,z=(((-1)**j+z*i)*i**b).rect  #generate x axis displacements 1,-1,1,-1, rotate x and z about y axis by b, store in x and z as reals
    q=(x+y*i)*i**c                 #rotate x and y about z axis, store result in q as complex number
  [90*(k+q/(z-4)),90*(k+q/(4+z))]} #generate "far" vertex q/(4+z) and "near" vertex q/-(4-z) opposite ends of body diagonal in 2d format.

  4.upto(15){|j|                   #iterate through 12 edges, use rect and + to convert the two complex numbers into a 4 element array for line method
    line *(p[j%4][0].rect+         #cycle through 4 vertices of the "normal" tetrahedron
     p[(j+j/4)%4][1].rect)         #draw to three vertices of the "inverted" tetrahedron. j/4=1,2,3, never 0
  }                                #so the three edges are drawn but the body diagonal is not.
}

ध्यान दें कि ऐतिहासिक कारणों से लाइन 9 में 90 का स्केल फैक्टर लागू किया जाता है (गोल्फिंग के लिए लाइन 2 में 90 डिग्री के समान चुना जाता है) लेकिन अंत में इस विशेष मूल्य का उपयोग करने में कोई गोल्फ लाभ नहीं था, इसलिए यह एक बन गया है मनमाना विकल्प।

Answer 2

HTML / CSS / JS, 739 बाइट्स, शायद गैर-प्रतिस्पर्धात्मक

लेकिन मैं बस सीएसएस 3 डी परिवर्तनों को दिखाना चाहता था।

w=_=>o.style.transform=`rotateZ(${z.value}deg) rotateY(${y.value}deg) rotateX(${-x.value}deg)`

input {
  width: 5em;
}

#c{width:90px;height:90px;margin:90px;position:relative;perspective:180px}#o{position:absolute;width:90px;height:90px;transform-style:preserve-3d;transform-origin:45px 45px 0px;}#o *{position:absolute;width:90px;height:90px;border:2px solid black}#f{transform:translateZ(45px)}#b{transform:rotateX(180deg)translateZ(45px)}#r{transform:rotateY(90deg)translateZ(45px)}#l{transform:rotateY(-90deg)translateZ(45px)}#u{transform:rotateX(90deg)translateZ(45px)}#d{transform:rotateX(-90deg)translateZ(45px)}

<div oninput=w()>
  X:<input id="x" type="number" value="0" min="0" max="360">
  Y:<input id="y" type="number" value="0" min="0" max="360">
  Z:<input id="z" type="number" value="0" min="0" max="360">
</div>
<!-- Above code for ease of use of snippet. Golfed version: <div oninput=w()><input id=x><input id=y><input id=z></div> -->

<div id=c><div id=o><div id=f></div><div id=b></div><div id=r></div><div id=l></div><div id=u></div><div id=d>

Comments

यह वास्तव में बहुत साफ दिखता है। मैंने पहले CSS3 के परिवर्तनों के साथ अनुभव किया, लेकिन मेरे पास इसके मुद्दे थे।

— बैलिंट

आपको लगता है कि गलत क्रम में घुमाव हैं। यह x तो y तब z होना चाहिए। आपके पास z है तो y तब x। @ Bálint पुष्टि कर सकता है।

— लेवल रिवर सेंट।

@LevelRiverSt जब मैंने इसे लिखा तो मुझे नहीं पता था कि आदेश क्या होना चाहिए, और मैं इसे परीक्षण के मामलों से बाहर काम नहीं कर सका, इसलिए मुझे अपडेट करने के लिए धन्यवाद। मैंने एक्स रोटेशन की दिशा में भी फ़्लिप किया है, इसलिए अब मैं सभी परीक्षण मामलों से मेल खाता हूं।

— नील

क्या आप अभी भी बाइट काउंट प्रदान कर सकते हैं? यहां तक ​​कि अगर जवाब गैर-प्रतिस्पर्धी हैं, तो उनके पास हमेशा एक बाइट की गिनती होनी चाहिए

— डाउनगोट

@Downgoat गॉल्फिड या अनगुल्फेड?

— नील

Answer 3

मेपल, 130 + 14 (प्रगति में)

with(plots):f:=(X,Y,Z)->plot3d(0,x=0..1,y=0..1,style=contour,tickmarks=[0,0,0],labels=["","",""],axes=boxed,orientation=[Z,-X,Y]);

यह एक बॉक्स के अंदर एक स्थिर फ़ंक्शन को प्लॉट करता है, फिर टिक्स, लेबल और फ़ंक्शन को छिपाने के लिए प्लॉट विकल्पों का उपयोग करता है। projection=.5विकल्पों में जोड़ने से कैमरा नज़दीक आता है, जिससे परिप्रेक्ष्य को देखा जा सकता है।
ऐनक फाइनल होने से पहले मैंने इसे लिखा था और x, y', z''इसके बजाय रोटेशन ऑर्डर है x, y, z। जब तक मैं कोणों को ठीक नहीं करता, तब तक यहां एक और समाधान है

पीओवी-रे, 182

#include"a.txt"
#include"shapes.inc"
camera{location 9*z look_at 0}
light_source{9*z color 1}
object{Wire_Box(<-2,-2,-2>,<2,2,2>,.01,0)texture{pigment{color rgb 1}}rotate<R.x,-R.y,-R.z>}

a.txtफ़ाइल के माध्यम से इनपुट पढ़ता है जिसमें रोटेशन कोण होने के
#declare R=<xx,yy,zz>;
साथ होना चाहिएxx,yy,zz

Comments

पीओवी-रे का उपयोग करने के लिए याय, यह एक शानदार कार्यक्रम है। दुर्भाग्य से, नियम अब बताते हैं कि कोई भी 3 डी क्यूब वर्ग का उपयोग नहीं किया जा सकता है।

— मील