ขนาดของดวงจันทร์ลึกลับ

ฉันแน่ใจว่าคุณเคยได้ยินว่าดวงจันทร์เปลี่ยนขนาดของมัน เมื่อคุณมีความรักและคุณโชคดีดวงจันทร์มีขนาดเกือบสองเท่าเมื่อเทียบกับสถานการณ์ปกติ บางคนบอกว่าเหตุผลคือบรรยากาศที่ทำหน้าที่เป็นเลนส์ คนอื่นคิดว่ามันเป็นเพียงเรื่องของการเปรียบเทียบกับวัตถุอื่น ๆ เช่นต้นไม้ในบริเวณใกล้เคียง อะไรก็ตามที่คุณอ่านคำอธิบายมันเป็นเรื่องส่วนตัว

ขนาดของวิทยาศาสตร์ดวงจันทร์

ตกลงเราเป็นโปรแกรมเมอร์ใช่ไหม เราพึ่งพาข้อเท็จจริงใช่ไหม ดังนั้นนี่คือการทดลอง:

1. ใช้กล้องที่ดีซึ่งรองรับการตั้งค่าเวลาและค่ารูรับแสงด้วยตนเอง
2. ตั้งค่ากล้องของคุณเป็นระดับการซูมสูงสุด
3. ออกไปถ่ายรูปดวงจันทร์เพื่อตรวจจับการตั้งค่าที่ดีที่สุดเพื่อให้ดวงจันทร์คมและแสงก็ดี
4. จำการตั้งค่า
5. ถ่ายภาพดวงจันทร์ด้วยการตั้งค่าเหล่านั้นทุกครั้งที่คุณคิดว่าดวงจันทร์มีขนาดใหญ่หรือเล็ก
6. คำนวณขนาดของดวงจันทร์เป็นพิกเซล

กล้องไม่โกหกใช่มั้ย ด้วยการนับพิกเซลที่สว่างเราสามารถวัดขนาดของดวงจันทร์ได้อย่างมีประสิทธิภาพ - อย่างน้อยเป็นพิกเซล

หากขนาดเท่ากันในรูปภาพทั้งหมดแสดงว่าเป็นข้อบกพร่องในสมองของเรา หากขนาดแตกต่างกันแสดงว่ามีห้องสำหรับเก็งกำไร

• ดวงจันทร์เติบโตขึ้นจริง ๆ (แต่มันกินอะไร)
• มีเอฟเฟ็กต์เลนส์บรรยากาศ
• ดวงจันทร์มีลักษณะเป็นวงรีและบางครั้งใกล้กว่าบางครั้งไกลจากโลกมากขึ้น
• ...

แต่ฉันจะปล่อยให้เปิดจนกว่างานของคุณจะเสร็จสมบูรณ์ แน่นอนว่าคุณต้องการทราบล่วงหน้าหากซอฟต์แวร์ของคุณสามารถคำนวณขนาดดวงจันทร์ได้อย่างถูกต้อง

งาน

ได้รับภาพที่ดีที่สุดของดวงจันทร์กรุณาคำนวณขนาดของดวงจันทร์ การปรับให้เหมาะสมคือ: พิกเซลเป็นสีดำหรือสีขาว ไม่มีอะไรในระหว่าง ไม่มีการลดรอยหยัก นั่นทำให้ง่ายใช่ไหม?

ข้อแม้: ดวงจันทร์ไม่เต็มคุณรู้ไหมว่ามันอาจเป็นเคียว! แต่ถึงแม้จะเป็นรูปร่างเคียวขนาดของดวงจันทร์ก็ใหญ่กว่า ดังนั้นคุณจะคำนวณขนาดเต็มได้ไหม

• โปรแกรมของคุณใช้ PNG เป็นอินพุตเช่นอาร์กิวเมนต์บรรทัดคำสั่งชื่อไฟล์ไปป์stdinหรือเป็นวัตถุบิตแมป (ของไลบรารีเฟรมเวิร์กมาตรฐาน) หากคุณเขียนฟังก์ชันแทนที่จะเป็นโปรแกรม
• โปรแกรมของคุณทำงานกับขนาดบิตแมปอินพุตที่สมเหตุสมผลไม่จำเป็นต้องเป็นแบบสแควร์ รับประกันความกว้างและความสูงขั้นต่ำ 150 พิกเซล
• พระจันทร์เต็มดวงครอบคลุมอย่างน้อย 25% ของภาพ
• โปรแกรมของคุณแสดงขนาดที่คำนวณได้ของดวงจันทร์เป็นพิกเซลราวกับว่ามันเป็นพระจันทร์เต็มดวง
• เราคิดว่าดวงจันทร์เป็นทรงกลมที่สมบูรณ์แบบ
• ขนาดที่แน่นอนเป็นจำนวนเต็มเสมอ แต่คุณสามารถส่งออกจำนวนทศนิยมหากการคำนวณของคุณส่งคืน
• ความแม่นยำควรอยู่ระหว่าง 98% ถึง 102% (นั่นเป็นการคาดเดามากกว่าสิ่งที่ฉันสามารถรับประกันได้ว่าจะทำได้ถ้าคุณคิดว่ามันยากเกินกว่าที่จะเข้าถึงได้โปรดแสดงความคิดเห็น)

อัปเดต :

• ศูนย์กลางของดวงจันทร์ไม่จำเป็นต้องอยู่ตรงกลางของภาพ
• พื้นที่ที่มองเห็นได้ต่ำสุดคือ 5% ของดวงจันทร์หรือ 1.25% ของจำนวนพิกเซลทั้งหมด
• ภาพถูกถ่ายในลักษณะที่ว่าพระจันทร์ทั้งดวงจะพอดีกับภาพกล่าวคือจำนวนพิกเซลทั้งหมดเป็นขอบเขตสูงสุดของขนาดดวงจันทร์
• ดวงจันทร์จะไม่ถูกครอบตัด / ถูกตัด

กลุ่มตัวอย่าง

คุณสามารถสร้างตัวอย่างของคุณเองโดยใช้ไฟล์ผสมผสานหากคุณต้องการ ฉันสร้างรูปภาพต่อไปนี้ให้คุณแล้ว คุณสามารถนับพิกเซลในไฟล์ PNG โดยใช้WhitePixelCounter.exe (ต้องการ. NET) เพื่อตรวจสอบว่าภาพมีพิกเซลสีดำและสีขาวเท่านั้นและมีจำนวนเท่าใด

รูปภาพ 256x256 พิกเซลต่อไปนี้แตกต่างกันในจำนวนพิกเซลสีขาว แต่ควรส่งผลให้ขนาดดวงจันทร์ที่คำนวณได้ของ 16416 พิกเซล

และรูปภาพ 177x177 พิกเซลเหล่านี้ควรส่งคืน 10241 พิกเซล ภาพโดยทั่วไปแล้วจะเหมือนกัน แต่คราวนี้มีการใช้กล้องที่มีความยาวโฟกัสแตกต่างกัน

ตัวอย่างที่ไม่ได้เป็นสแควร์และไม่อยู่กึ่งกลางมีผลลัพธ์ 9988

โอ้ตอนนี้ฉันยังไม่มีการใช้งานอ้างอิงและฉันยังไม่รู้ด้วยซ้ำว่าฉันสามารถนำบางสิ่งไปใช้หรือไม่ แต่ในสมองของฉันมีความเชื่ออย่างแรงกล้าที่บอกฉันว่าต้องแก้ปัญหาทางคณิตศาสตร์ได้

กฎระเบียบ

นี่คือรหัสกอล์ฟ รหัสที่สั้นที่สุดของ 2015-03-30 ได้รับการยอมรับ

Mathematica 126 119 109 ไบต์

Mathematica สามารถวัดการยืดตัวของส่วนประกอบในภาพได้ พระจันทร์เต็มดวงที่มีความสมมาตรอย่างสมบูรณ์มีการยืดตัวที่ 0 ในระดับ 0 ถึง 1

ดวงจันทร์ที่ลดน้อยลงจะยาวขึ้นเรื่อย ๆ จนถึงสูงสุดประมาณ 0.8

0.998 -0.788 x-0.578 x^2 เป็นแบบจำลองเชิงประจักษ์ (จากภาพถ่ายขนาดใหญ่) สำหรับ `ทำนายความบริบูรณ์ของดวงจันทร์ (ตามพื้นที่) ได้รับการยืดตัว

ฉันปรับโมเดล1- 0.788 x -0.578 x^2ให้มีความยาวเท่ากับศูนย์ (ฟูลมูน) แบบจำลองจะคืนค่า 1 สำหรับระดับสเกลของพิกเซล มันช่วยประหยัด 4 ไบต์และยังคงอยู่ภายในขีดจำกัดความแม่นยำ

รุ่นนี้ใช้กับภาพทุกขนาด ภาพดวงจันทร์ไม่จำเป็นต้องอยู่กึ่งกลาง นอกจากนี้ยังไม่จำเป็นต้องครอบคลุมสัดส่วนของภาพถ่าย

นี่คือจุดข้อมูล (การยืดตัว, การแสดง MoonPixels / fullMoonPixels) สำหรับภาพขนาดใหญ่และแบบจำลองพาราโบลาที่สร้างขึ้นเพื่อให้พอดีกับข้อมูล โมเดลเชิงเส้นพอดีกับตกลง แต่โมเดลสมการกำลังสองตายบนภายในขีด จำกัด (ดูด้านล่าง)

นี่คือข้อมูลจากภาพขนาดใหญ่ ดังนั้นรูปแบบคือ

ด้านล่างข้อมูล (จุดสีแดง) มาจากภาพขนาดเล็ก แบบจำลอง (เส้นโค้งสีน้ำเงิน) เป็นสิ่งที่สร้างขึ้นโดยรูปภาพขนาดใหญ่รูปแบบเดียวกับที่แสดงด้านบน

เสี้ยวที่เล็กที่สุดมีพื้นที่พระจันทร์เต็มดวง 7.5% (รูปพระจันทร์เสี้ยวที่เล็กที่สุดในภาพถ่ายขนาดใหญ่คือ 19% ของพระจันทร์เต็มดวง) หากรูปแบบสมการกำลังสองได้ยึดรูปถ่ายขนาดเล็กไว้ด้านล่างพอดีจะดีกว่าเพราะมันรองรับเสี้ยวเล็ก ๆ เท่านั้น แบบจำลองที่แข็งแกร่งซึ่งจะยืนขึ้นภายใต้เงื่อนไขที่หลากหลายรวมถึงเสี้ยวเล็ก ๆ จะทำจากภาพที่มีขนาดใหญ่ขึ้น

ความใกล้ชิดของความพอดีแสดงให้เห็นว่าแบบจำลองนั้นไม่ได้เขียนรหัสแบบยากสำหรับรูปภาพที่กำหนด เราค่อนข้างมั่นใจได้ว่าการยืดตัวของดวงจันทร์นั้นไม่ขึ้นอยู่กับขนาดของภาพถ่าย

fใช้ภาพiเป็นอินพุตและเอาต์พุตขนาดที่คาดการณ์ของพระจันทร์เต็มดวงเป็นพิกเซล มันใช้งานได้กับภาพนอกศูนย์

ตามข้อมูลด้านล่างแสดงว่าเป็นกรณีทดสอบทั้งหมดยกเว้นหนึ่งกรณี ดวงจันทร์ถูกจัดเรียงจากเต็มไปมากที่สุดลดลง

i_~c~t_ := Max@ComponentMeasurements[i, t][[All, 2]];
f@i_ := i~c~"Count"/(1 - 0.788 x - 0.578 x^2 /. x -> i~c~"Elongation")

องค์ประกอบภาพมากกว่าหนึ่งรายการอาจปรากฏในภาพถ่าย แม้แต่พิกเซลเดียวที่แยกออกจากส่วนอื่น ๆ จะถือว่าเป็นองค์ประกอบที่แตกต่างกัน ด้วยเหตุนี้จึงมีความจำเป็นต้องค้นหาส่วนประกอบ "ทั้งหมด" เพื่อค้นหาส่วนประกอบที่มีจำนวนพิกเซลมากขึ้น (หนึ่งในภาพถ่ายขนาดเล็กมีองค์ประกอบภาพมากกว่าหนึ่ง)

รูปภาพขนาดใหญ่

การคาดการณ์ขนาดดวงจันทร์ที่ทำจากภาพถ่ายขนาดใหญ่นั้นมีความแม่นยำเหมือนกัน

{"predicted size of full moon", f[#] & /@ large}
{"accuracy", %[[2]]/16416}

{"ขนาดพระจันทร์เต็มดวงที่คาดการณ์ไว้", {16422. , 16270.9, 16420.6, 16585.5, 16126.5, 16151.6}}

{"ความแม่นยำ", {1.00037, 0.991161, 1.00028, 1.01033, 0.982367, 0.983891}}

รูปภาพขนาดเล็ก

การคาดการณ์ขนาดของดวงจันทร์ที่ทำจากภาพถ่ายขนาดเล็กนั้นมีความเหมือนกันโดยมีข้อยกเว้นอย่างหนึ่งคือภาพสุดท้าย ฉันสงสัยว่าปัญหาเกิดจากข้อเท็จจริงที่ว่าเสี้ยวแคบมาก

{"predicted sizes of full moon", f[#] & /@ small}
{"accuracy", %[[2]]/10241}

{"ขนาดพระจันทร์เต็มดวงที่คาดการณ์ไว้", {10247.3, 10161. , 10265.6, 10391. , 10058.9, 7045.91}}
{"ความแม่นยำ", {1.00061, 0.992192, 1.0024, 1.01465, 0.982221,}

J, 227 207 ไบต์ (ข้อผิดพลาดสูงสุด 1.9%)

แนวคิดหลักของฉันคือถ้าเราสามารถหา 3 จุดบนรูปร่างของดวงจันทร์ซึ่งอยู่บนรูปร่างของพระจันทร์เต็มดวงเราก็สามารถคำนวณจุดกลมของจุดเหล่านี้ได้ วงกลมนั้นจะเป็นพระจันทร์เต็มดวง

หากเราพบจุดสีขาวสองจุดที่มีระยะทางสูงสุดพวกมันจะเป็นจุดเช่นนี้เสมอเพราะพวกมันจะเป็นเส้นทแยงมุมจริงในพระจันทร์เต็มดวงหรือจุดสิ้นสุดของเสี้ยว เราสามารถหาจุดที่มีระยะทางไกลที่สุดในกราฟใด ๆ โดยการเลือกจุดที่ไกลที่สุดจากจุดเริ่มต้นที่กำหนดและจากนั้นเลือกจุดที่ไกลที่สุดจากจุดที่เลือก

เราพบจุดที่สามที่มีมูลค่าสูงสุดของผลิตภัณฑ์ของระยะทางจากจุดก่อนหน้า สิ่งนี้จะอยู่บนรูปร่างและด้านนอกของเสี้ยวหรือด้านที่ใหญ่กว่าของ gibbous

เส้นผ่านศูนย์กลางของวงกลมรอบนั้นคำนวณโดยความยาวของด้านหนึ่งหารด้วยไซนัสของมุมตรงกันข้าม

ความซับซ้อนของเวลาของวิธีนี้คือขนาดเชิงเส้นของภาพอินพุต

รหัส

f=.3 :0
load'graphics/png'
i=.readpng y
p=.(,i=_1)#|:,"%.0 1|:,"0/&>/<@i."*$i
s=.%:+/|:*:(-1|.]) (([,],:m@(*&d))(m@d))(m=.p{~(i.>./)@])(d=.+/@:*:@((|:p)-])) 0{p
o.*:-:({.s)%0 o.((+/-2*{.)*:s)%2**/}.s
)

ฟังก์ชันคาดว่าชื่อไฟล์อินพุตเป็นสตริง

(สำหรับรุ่นตรวจสอบประวัติการแก้ไขที่ตรวจสอบได้มากกว่า (เล็กน้อย))

คำอธิบายรหัส

• p คือรายการพิกัดพิกเซลสีขาว (เรียกว่าคะแนนในอนาคต)
• ฟังก์ชั่น d คำนวณระยะทางระหว่างองค์ประกอบของ p และจุดที่กำหนด

• ส่วนที่สองของคำจำกัดความของ s สร้างรายการ 3 จุด:

  • A คือจุดที่ไกลที่สุดจากจุดแรกในรายการ
  • B คือจุดที่ไกลที่สุดจาก A
  • C คือจุดที่มีค่าสูงสุดของรูปแบบระยะทาง A คูณระยะทางจาก B

• s คือความยาวด้านข้างของสามเหลี่ยม ABC

• บรรทัดสุดท้ายคำนวณพื้นที่วงกลมของ ABC ซึ่งเป็นพระจันทร์เต็มดวง

ผล

ข้อผิดพลาดที่ใหญ่ที่สุดคือ 1.9%

ภาพอยู่ในลำดับเดียวกันกับคำถาม

Output  Accuracy
----------------
  16407 0.999453 NB. Large images
16375.3 0.997523
16223.9 0.988301
16241.5 0.989369
16262.6 0.990654
16322.1 0.994279
10235.3 0.999445 NB. Small images
10235.3 0.999444
10221.2 0.998067
10220.3 0.997978
  10212 0.997169
10229.6  0.99889
9960.42 0.997239 NB. Offset images
9872.22 0.988408
10161.8   1.0174
9874.95 0.988681
 9805.9 0.981768

Matlab 162 156 (ไม่ค่อนข้างอยู่ในระยะขอบผิดพลาดปัจจุบัน)

ก่อนอื่น: ความแม่นยำต่ำกว่า 2% สำหรับทุกภาพยกเว้นภาพหนึ่งภาพในแต่ละซีรีย์ซึ่งมีขนาดใหญ่กว่า (ประมาณ 5% และ 14%) วิธีการของฉันคือค้นหาพิกเซลสองดวงของดวงจันทร์ที่อยู่ห่างกันมากที่สุดแล้วใช้สิ่งนี้เป็นค่าประมาณเส้นผ่านศูนย์กลาง

a=imread(input(''));                 %read input image
b=a(:,:,1)>0;                        %binarize red channel
s=size(b);                           %get size of the image
[x,y]=meshgrid(1:s(1),1:s(2));       
z=(x+i*y).*b;z=z(z~=0);              %find the coordinates of all white pixels (as a list)
o=ones(size(z(:)))*z(:)';            
disp(max(max(abs(o-o.').^2))*pi/4);  %calculate the maximum of the distance between each possible pair and evaluate area formula

เหล่านี้คือผลลัพธ์ที่แม่นยำ (การเบี่ยงเบนเชิงสัมพันธ์1 - (predicted size / real size))

0.0006 0.0025 0.0169 0.0500 0.0521 0.0113 0.0006 0.0006 0.0026 0.0472 0.1383 0.0131

C # - 617

วิธีนี้ไม่สามารถใช้ได้กับทุกภาพเพราะในภาพใดภาพหนึ่งความชัน (m) จะไม่สิ้นสุด

มีการกล่าวถึงหลักการก่อนหน้านี้:

1. ค้นหาสองจุดด้วยระยะทางสูงสุด (สีแดง)
2. ลองนึกภาพเส้นแบ่งระหว่างพวกเขา (สีแดง)
3. ลองนึกภาพเส้นที่มีมุมเป็นรูปสี่เหลี่ยมผืนผ้าที่อยู่ตรงกลาง (สีเขียว)
4. ค้นหาจุดสีขาวบนเส้นสีเขียว
5. ใช้อันที่มีระยะทางสูงสุดจากจุดอื่น ๆ (สีเขียว)
6. คำนวณพื้นที่ของวงกลมจากสามจุด

กรณีที่เป็นปัญหาคือกรณีนี้ซึ่งความชันนั้นไม่มีที่สิ้นสุด มันเป็นไปได้ที่จะแก้ปัญหาโดยการหมุนภาพ 90 องศาหรือในรหัสห่วงมากกว่าแกนแทนyx

double A(Bitmap b){var a=new List<P>();for(var y=0;y<b.Height;y++)for(var x=0;x<b.Width;x++)if(b.GetPixel(x,y).R>0)a.Add(new P{x=x,y=y});double c=0.0,d=0.0,e=0.0,f=0.0,g=0.0,n=double.MaxValue;foreach(var h in a)foreach(var i in a){var t=Math.Sqrt(Math.Pow(h.x-i.x,2)+Math.Pow(h.y-i.y,2));if(t>c){d=h.x;f=i.x;e=h.y;g=i.y;c=t;}}c=(f-d)/(e-g);for(int x=0;x<b.Width;x++){int y=(int)(c*x+((e+g)/2-c*(d+f)/2));if(y>=0&&y<b.Height&&b.GetPixel(x,y).R>0){var s=(g-e)/(f-d);var q=(y-g)/(x-f);var j=(s*q*(e-y)+q*(d+f)-s*(f+x))/(2*(q-s));var k=-(j-(d+f)/2)/s+(e+g)/2;var l=(j-d)*(j-d)+(k-e)*(k-e);if(l<n)n=l;}}return Math.PI*n;}

ความแม่นยำขั้นต่ำคือ

• + 1,89% สำหรับภาพ 256 พิกเซล
• -0.55% สำหรับรูปภาพ 177 พิกเซล
• -1.66% สำหรับรูปภาพที่ไม่ใช่สี่เหลี่ยมจัตุรัส