দিক অনুপাত গণনা করার জন্য অ্যালগরিদম কী?

Question 1

আমি পুরো উইন্ডোতে ফিট করার জন্য একটি চিত্র ক্রপ করার জন্য এটি জাভাস্ক্রিপ্ট দিয়ে ব্যবহার করার পরিকল্পনা করছি।

সম্পাদনা : আমি একটি তৃতীয় পক্ষের উপাদান ব্যবহার করব যা কেবলমাত্র: 4:3, 16:9। এর বিন্যাসে অনুপাতের অনুপাত গ্রহণ করে ।

Question 2

আমি তোমাদের কাছে এক ব্যবহারযোগ্য অনুপাত খুঁজছেন জড়ো integer:integerমত সমাধান 16:9একটি বদলে float:1মত সমাধান 1.77778:1।

যদি তা হয় তবে আপনাকে যা করতে হবে তা হ'ল সর্বশ্রেষ্ঠ সাধারণ বিভাজক (জিসিডি) সন্ধান করুন এবং উভয় মানকে সেই দ্বারা ভাগ করুন। জিসিডি হ'ল সর্বোচ্চ সংখ্যা যা সমানভাবে উভয় সংখ্যাকে ভাগ করে দেয়। সুতরাং 6 এবং 10 এর জন্য জিসিডি 2, 44 এবং 99 এর জন্য জিসিডি 11।

উদাহরণস্বরূপ, একটি 1024x768 মনিটরের 256 এর একটি জিসিডি রয়েছে you আপনি যখন উভয় মানকে ভাগ করে নেন আপনি 4x3 বা 4: 3 পান।

একটি (পুনরাবৃত্ত) জিসিডি অ্যালগরিদম:

function gcd (a,b):
    if b == 0:
        return a
    return gcd (b, a mod b)

সি তে:

static int gcd (int a, int b) {
    return (b == 0) ? a : gcd (b, a%b);
}

int main(void) {
    printf ("gcd(1024,768) = %d\n",gcd(1024,768));
}

এবং এখানে কিছু সম্পূর্ণ এইচটিএমএল / জাভাস্ক্রিপ্ট যা স্ক্রিনের আকার সনাক্ত করতে এবং সেই থেকে দিক অনুপাত গণনা করার একটি উপায় দেখায় shows এটি এফএফ 3 এ কাজ করে, আমি নিশ্চিত নই যে অন্যান্য ব্রাউজারগুলির জন্য screen.widthএবং কী সমর্থন করে screen.height।

<html><body>
    <script type="text/javascript">
        function gcd (a, b) {
            return (b == 0) ? a : gcd (b, a%b);
        }
        var w = screen.width;
        var h = screen.height;
        var r = gcd (w, h);
        document.write ("<pre>");
        document.write ("Dimensions = ", w, " x ", h, "<br>");
        document.write ("Gcd        = ", r, "<br>");
        document.write ("Aspect     = ", w/r, ":", h/r);
        document.write ("</pre>");
    </script>
</body></html>

এটি আউটপুট দেয় (আমার অদ্ভুত প্রশস্ত স্ক্রিন মনিটরে):

Dimensions = 1680 x 1050
Gcd        = 210
Aspect     = 8:5

অন্যান্য যেগুলিতে আমি এটি পরীক্ষা করেছি:

Dimensions = 1280 x 1024
Gcd        = 256
Aspect     = 5:4

Dimensions = 1152 x 960
Gcd        = 192
Aspect     = 6:5

Dimensions = 1280 x 960
Gcd        = 320
Aspect     = 4:3

Dimensions = 1920 x 1080
Gcd        = 120
Aspect     = 16:9

আমি ইচ্ছা করি বাড়িতে আমার এটি শেষ ছিল তবে না, দুর্ভাগ্যক্রমে এটি একটি ওয়ার্ক মেশিন।

আপনি যদি অনুপাতের অনুপাতটি খুঁজে পান তবে আপনি যা করেন তা আপনার গ্রাফিক পুনরায় আকারের সরঞ্জাম দ্বারা সমর্থিত নয়, এটি অন্য একটি বিষয়। আমি সন্দেহ করি যে চিঠি-বক্সিং লাইনগুলি যুক্ত করা (সেখানে আপনি যখন আপনি একটি প্রশস্ত স্ক্রিনের মুভি দেখছেন তখন আপনি নিজের পুরানো টিভিতে শীর্ষে এবং নীচে পাবেন) এর মতো সর্বোত্তম বাজি থাকবে। চিত্রটি প্রয়োজনীয়তা পূরণ না হওয়া পর্যন্ত আমি এগুলিকে শীর্ষ / নীচে বা পাশগুলিতে যুক্ত করব (যে কোনও একটিতে ন্যূনতম-বক্সিং লাইনগুলির সর্বনিম্ন সংখ্যার ফলাফল হয়)।

আপনি যে বিষয়টি বিবেচনা করতে চাইতে পারেন তা হ'ল 16: 9 থেকে 5: 4 থেকে পরিবর্তিত একটি চিত্রের গুণাবলী - আমি এখনও মনে করি যে অবিশ্বাস্যরূপে লম্বা, পাতলা কাউবয়গুলি আমি যৌবনে টেলিভিশনে দেখতাম চিঠি-বক্সিংয়ের প্রচলনের আগে। আপনি অনুপাতের অনুপাত অনুসারে আলাদা আলাদা চিত্র রাখাই ভাল এবং তারের নিচে প্রেরণের আগে আসল পর্দার মাত্রার জন্য সঠিকটিকে পুনরায় আকার দিন।

Question 3

aspectRatio = width / height

যদি আপনি পরে কি হয়। তারপরে আপনি এটির লক্ষ্য স্থানের মাত্রাগুলির একটি দ্বারা অন্যটি (যেটি অনুপাত বজায় রাখে) বের করার জন্য গুণ করতে পারেন উদাহরণস্বরূপ

widthT = heightT * aspectRatio
heightT = widthT / aspectRatio

Question 4

প্যাক্সিয়াবলোর উত্তর দুর্দান্ত, তবে প্রচুর প্রচলিত রেজোলিউশন রয়েছে যেগুলির একটি নির্দিষ্ট দিকে মাত্র কয়েক বা কম পিক্সেল রয়েছে এবং সর্ববৃহৎ সাধারণ বিভাজক পদ্ধতির তাদের কাছে ভয়াবহ ফলাফল দেয়।

উদাহরণস্বরূপ নিন 1360x765 এর ভাল আচরণিত রেজোলিউশন যা জিসিডি পদ্ধতির সাহায্যে একটি দুর্দান্ত 16: 9 অনুপাত দেয়। বাষ্প অনুসারে, এই রেজোলিউশনটি কেবল তার ব্যবহারকারীর 0.01% দ্বারা ব্যবহৃত হয়, যখন 1366x768 একটি তীব্র 18.9% দ্বারা ব্যবহৃত হয়। আসুন আমরা জিসিডি পদ্ধতির ব্যবহারটি কী তা দেখি:

1360x765 - 16:9 (0.01%)
1360x768 - 85:48 (2.41%)
1366x768 - 683:384 (18.9%)

আমরা সেই 683: 384 অনুপাতটি নিকটতম, 16: 9 অনুপাতের সাথে গোল করতে চাই।

আমি একটি পাইথন স্ক্রিপ্ট লিখেছিলাম যা বাষ্প হার্ডওয়্যার সমীক্ষা পৃষ্ঠা থেকে আটকানো সংখ্যার সাথে একটি পাঠ্য ফাইলকে বিশ্লেষণ করে এবং সমস্ত রেজোলিউশন এবং নিকটতম পরিচিত অনুপাতগুলি পাশাপাশি প্রতিটি অনুপাতের প্রসারণ (যা আমি এটি শুরু করার সময় আমার লক্ষ্য ছিল):

# Contents pasted from store.steampowered.com/hwsurvey, section 'Primary Display Resolution'
steam_file = './steam.txt'

# Taken from http://upload.wikimedia.org/wikipedia/commons/thumb/f/f0/Vector_Video_Standards4.svg/750px-Vector_Video_Standards4.svg.png
accepted_ratios = ['5:4', '4:3', '3:2', '8:5', '5:3', '16:9', '17:9']

#-------------------------------------------------------
def gcd(a, b):
    if b == 0: return a
    return gcd (b, a % b)

#-------------------------------------------------------
class ResData:

    #-------------------------------------------------------
    # Expected format: 1024 x 768 4.37% -0.21% (w x h prevalence% change%)
    def __init__(self, steam_line):
        tokens = steam_line.split(' ')
        self.width  = int(tokens[0])
        self.height = int(tokens[2])
        self.prevalence = float(tokens[3].replace('%', ''))

        # This part based on pixdiablo's gcd answer - http://stackoverflow.com/a/1186465/828681
        common = gcd(self.width, self.height)
        self.ratio = str(self.width / common) + ':' + str(self.height / common)
        self.ratio_error = 0

        # Special case: ratio is not well behaved
        if not self.ratio in accepted_ratios:
            lesser_error = 999
            lesser_index = -1
            my_ratio_normalized = float(self.width) / float(self.height)

            # Check how far from each known aspect this resolution is, and take one with the smaller error
            for i in range(len(accepted_ratios)):
                ratio = accepted_ratios[i].split(':')
                w = float(ratio[0])
                h = float(ratio[1])
                known_ratio_normalized = w / h
                distance = abs(my_ratio_normalized - known_ratio_normalized)
                if (distance < lesser_error):
                    lesser_index = i
                    lesser_error = distance
                    self.ratio_error = distance

            self.ratio = accepted_ratios[lesser_index]

    #-------------------------------------------------------
    def __str__(self):
        descr = str(self.width) + 'x' + str(self.height) + ' - ' + self.ratio + ' - ' + str(self.prevalence) + '%'
        if self.ratio_error > 0:
            descr += ' error: %.2f' % (self.ratio_error * 100) + '%'
        return descr

#-------------------------------------------------------
# Returns a list of ResData
def parse_steam_file(steam_file):
    result = []
    for line in file(steam_file):
        result.append(ResData(line))
    return result

#-------------------------------------------------------
ratios_prevalence = {}
data = parse_steam_file(steam_file)

print('Known Steam resolutions:')
for res in data:
    print(res)
    acc_prevalence = ratios_prevalence[res.ratio] if (res.ratio in ratios_prevalence) else 0
    ratios_prevalence[res.ratio] = acc_prevalence + res.prevalence

# Hack to fix 8:5, more known as 16:10
ratios_prevalence['16:10'] = ratios_prevalence['8:5']
del ratios_prevalence['8:5']

print('\nSteam screen ratio prevalences:')
sorted_ratios = sorted(ratios_prevalence.items(), key=lambda x: x[1], reverse=True)
for value in sorted_ratios:
    print(value[0] + ' -> ' + str(value[1]) + '%')

কৌতূহলের জন্য, এগুলি বাষ্প ব্যবহারকারীদের মধ্যে স্ক্রিন অনুপাতের প্রসার (অক্টোবর ২০১২ হিসাবে):

16:9 -> 58.9%
16:10 -> 24.0%
5:4 -> 9.57%
4:3 -> 6.38%
5:3 -> 0.84%
17:9 -> 0.11%

Question 5

আমি অনুমান করি আপনি 4: 3 এবং 16: 9 এর মধ্যে কোনটি সবচেয়ে উপযুক্ত।

function getAspectRatio(width, height) {
    var ratio = width / height;
    return ( Math.abs( ratio - 4 / 3 ) < Math.abs( ratio - 16 / 9 ) ) ? '4:3' : '16:9';
}

Question 6

মূলত অজগরে রচনা করা অনুপাতের অনুপাত গণনা কোড থেকে জাভাস্ক্রিপ্টে স্থায়ীভাবে আবদ্ধতার সাথে সামঞ্জস্যপূর্ণ স্তরের জেমস ফারির সেরা যুক্তিসঙ্গত অনুমানের অ্যালগরিদমের একটি সংস্করণ এখানে রয়েছে ।

width/heightভগ্নাংশের সংখ্যা / ডিনোমিনেটরের জন্য পদ্ধতিটি একটি ভাসা ( ) এবং একটি উচ্চতর সীমা নেয় takes

নীচের উদাহরণে আমি একটি উচ্চতর সীমা নির্ধারণ করছি 50কারণ আমার অন্যান্য উত্তরগুলিতে তালিকাভুক্ত প্লেইন অ্যালগরিদমের পরিবর্তে আমার (1.77835051546) (1.77777777778) 1035x582হিসাবে বিবেচনা করা দরকার।16:9345:194gcd

<html>
<body>
<script type="text/javascript">
function aspect_ratio(val, lim) {

    var lower = [0, 1];
    var upper = [1, 0];

    while (true) {
        var mediant = [lower[0] + upper[0], lower[1] + upper[1]];

        if (val * mediant[1] > mediant[0]) {
            if (lim < mediant[1]) {
                return upper;
            }
            lower = mediant;
        } else if (val * mediant[1] == mediant[0]) {
            if (lim >= mediant[1]) {
                return mediant;
            }
            if (lower[1] < upper[1]) {
                return lower;
            }
            return upper;
        } else {
            if (lim < mediant[1]) {
                return lower;
            }
            upper = mediant;
        }
    }
}

document.write (aspect_ratio(800 / 600, 50) +"<br/>");
document.write (aspect_ratio(1035 / 582, 50) + "<br/>");
document.write (aspect_ratio(2560 / 1440, 50) + "<br/>");

    </script>
</body></html>

ফলাফল:

 4,3  // (1.33333333333) (800 x 600)
 16,9 // (1.77777777778) (2560.0 x 1440)
 16,9 // (1.77835051546) (1035.0 x 582)

Question 7

কেবলমাত্র যদি আপনি একটি পারফরম্যান্স freak ...

একটি আয়তক্ষেত্রের অনুপাত গণনা করার দ্রুততম উপায় (জাভাস্ক্রিপ্টে) এটি একটি সত্য বাইনারি গ্রেট সাধারণ বিভাজক অ্যালগরিদম ব্যবহার করে।

(সমস্ত গতি এবং সময় পরীক্ষা অন্যদের দ্বারা সম্পন্ন করা হয়েছে, আপনি এখানে একটি মানদণ্ড পরীক্ষা করতে পারেন: https://lemire.me/blog/2013/12/26/fastest-way-to-compute-the-greatest-common-divisor / )

এই যে এটা:

/* the binary Great Common Divisor calculator */
function gcd (u, v) {
    if (u === v) return u;
    if (u === 0) return v;
    if (v === 0) return u;

    if (~u & 1)
        if (v & 1)
            return gcd(u >> 1, v);
        else
            return gcd(u >> 1, v >> 1) << 1;

    if (~v & 1) return gcd(u, v >> 1);

    if (u > v) return gcd((u - v) >> 1, v);

    return gcd((v - u) >> 1, u);
}

/* returns an array with the ratio */
function ratio (w, h) {
	var d = gcd(w,h);
	return [w/d, h/d];
}

/* example */
var r1 = ratio(1600, 900);
var r2 = ratio(1440, 900);
var r3 = ratio(1366, 768);
var r4 = ratio(1280, 1024);
var r5 = ratio(1280, 720);
var r6 = ratio(1024, 768);


/* will output this: 
r1: [16, 9]
r2: [8, 5]
r3: [683, 384]
r4: [5, 4]
r5: [16, 9]
r6: [4, 3]
*/

স্নিপেট প্রসারিত করুন

Question 8

এখানে আমার সমাধানটি হ'ল এটি বেশ সোজা সামনে যেহেতু আমি যতটা যত্ন নিই তা জিসিডি বা এমনকি সঠিক অনুপাত নয়: কারণ তারপরে আপনি 345/113 এর মতো অদ্ভুত জিনিস পান যা মানুষের বোধগম্য নয়।

আমি মূলত গ্রহণযোগ্য ল্যান্ডস্কেপ, বা প্রতিকৃতি অনুপাত এবং তাদের "মান "টিকে একটি ভাসা হিসাবে সেট করি ... আমি তারপরে আমার অনুপাতের আমার ফ্লোট সংস্করণটি তুলনা করি এবং যা সর্বনিম্ন পরম মানের পার্থক্যটি আইটেমের নিকটতম অনুপাত is এইভাবে যখন ব্যবহারকারী এটি 16: 9 তৈরি করে তবে নীচে থেকে 10 পিক্সেল সরিয়ে দেয় এটি এখনও 16: 9 হিসাবে গণনা করা হয় ...

accepted_ratios = {
    'landscape': (
        (u'5:4', 1.25),
        (u'4:3', 1.33333333333),
        (u'3:2', 1.5),
        (u'16:10', 1.6),
        (u'5:3', 1.66666666667),
        (u'16:9', 1.77777777778),
        (u'17:9', 1.88888888889),
        (u'21:9', 2.33333333333),
        (u'1:1', 1.0)
    ),
    'portrait': (
        (u'4:5', 0.8),
        (u'3:4', 0.75),
        (u'2:3', 0.66666666667),
        (u'10:16', 0.625),
        (u'3:5', 0.6),
        (u'9:16', 0.5625),
        (u'9:17', 0.5294117647),
        (u'9:21', 0.4285714286),
        (u'1:1', 1.0)
    ),
}


def find_closest_ratio(ratio):
    lowest_diff, best_std = 9999999999, '1:1'
    layout = 'portrait' if ratio < 1.0 else 'landscape'
    for pretty_str, std_ratio in accepted_ratios[layout]:
        diff = abs(std_ratio - ratio)
        if diff < lowest_diff:
            lowest_diff = diff
            best_std = pretty_str
    return best_std


def extract_ratio(width, height):
    try:
        divided = float(width)/float(height)
        if divided == 1.0: return '1:1'
        return find_closest_ratio(divided)
    except TypeError:
        return None

Question 9

জিসিডি অনুসন্ধানের বিকল্প সমাধান হিসাবে, আমি আপনাকে মানক মানগুলির একটি সেট বিরুদ্ধে পরীক্ষা করার পরামর্শ দিই। আপনি উইকিপিডিয়ায় একটি তালিকা পেতে পারেন ।

Question 10

আমি এখানে আপনার ভিডিও সম্পর্কে কথা বলছি ধরে নিচ্ছি, সেক্ষেত্রে আপনার উত্স ভিডিওর পিক্সেল দিক অনুপাত সম্পর্কেও চিন্তার প্রয়োজন হতে পারে। উদাহরণ স্বরূপ.

পল ডিভি 720x576 এর রেজোলিউশনে আসে। যা এর 4: 3 এর মতো দেখায়। এখন পিক্সেল অ্যাস্পেক্ট রেশিও (PAR) এর উপর নির্ভর করে স্ক্রিনের অনুপাত 4: 3 বা 16: 9 হতে পারে।

আরও তথ্যের জন্য এখানে http://en.wikedia.org/wiki/Pixel_aspect_ratio দেখুন

আপনি স্কোয়ার পিক্সেল Aspect تناسب পেতে পারেন, এবং প্রচুর ওয়েব ভিডিও তা হ'ল তবে আপনি অন্যান্য ক্ষেত্রেও নজর রাখতে চাইতে পারেন।

আশাকরি এটা সাহায্য করবে

চিহ্ন

Question 11

অন্যান্য উত্তরের উপর ভিত্তি করে, পাইথনে আমার প্রয়োজনীয় নম্বরগুলি এখানে কীভাবে পেয়েছি;

from decimal import Decimal

def gcd(a,b):
    if b == 0:
        return a
    return gcd(b, a%b)

def closest_aspect_ratio(width, height):
    g = gcd(width, height)
    x = Decimal(str(float(width)/float(g)))
    y = Decimal(str(float(height)/float(g)))
    dec = Decimal(str(x/y))
    return dict(x=x, y=y, dec=dec)

>>> closest_aspect_ratio(1024, 768)
{'y': Decimal('3.0'), 
 'x': Decimal('4.0'), 
 'dec': Decimal('1.333333333333333333333333333')}

Question 12

আমি বিশ্বাস করি যে অনুপাতটি প্রস্থকে উচ্চতা দ্বারা বিভক্ত করা হয়।

 r = w/h

Question 13

আমার মনে হয় আপনি যা চাইছেন এটি এটি করে:

webdeveloper.com - ভগ্নাংশের দশমিক

প্রস্থ / উচ্চতা আপনাকে দশমিক দেয়, '/' এর পরিবর্তে ":" দিয়ে ভগ্নাংশে রূপান্তরিত করে আপনাকে একটি "অনুপাত" দেয়।

Question 14

পাইথনের এই অ্যালগরিদম আপনাকে সেখানকার পথে অংশ দেয়।

উইন্ডো যদি মজার আকার হয় তবে কি হবে তা বলুন।

হতে পারে আপনার যা থাকা উচিত তা সমস্ত গ্রহণযোগ্য অনুপাতের একটি তালিকা (তৃতীয় পক্ষের উপাদান)। তারপরে, আপনার উইন্ডোটির সবচেয়ে কাছের ম্যাচটি সন্ধান করুন এবং সেই অনুপাতটি তালিকা থেকে ফিরে আসুন।

Question 15

এটি করার এক বিস্ময়কর উপায় কিন্তু রেজোলিউশনটিকে দিক হিসাবে ব্যবহার করুন। ইজি

1024: 768

অথবা আপনি চেষ্টা করতে পারেন

var w = screen.width;
var h = screen.height;
for(var i=1,asp=w/h;i<5000;i++){
  if(asp*i % 1==0){
    i=9999;
    document.write(asp*i,":",1*i);
  }
}

Question 16

function ratio(w, h) {
    function mdc(w, h) {
        var resto;
        do {
            resto = w % h;

            w = h;
            h = resto;

        } while (resto != 0);

        return w;
    }

    var mdc = mdc(w, h);


    var width = w/mdc;
    var height = h/mdc;

    console.log(width + ':' + height);
}

ratio(1920, 1080);

Question 17

আমার ক্ষেত্রে আমি এই জাতীয় কিছু চাই

[10,5,15,20,25] -> [2, 1, 3, 4, 5]

function ratio(array){
  let min = Math.min(...array);
  let ratio = array.map((element)=>{
    return element/min;
  });
  return ratio;
}
document.write(ratio([10,5,15,20,25]));  // [ 2, 1, 3, 4, 5 ]

স্নিপেট প্রসারিত করুন

Question 18

আপনি সর্বদা সাধারণ দিক অনুপাতের উপর ভিত্তি করে একটি সারণী তৈরি করে শুরু করতে পারেন। পরীক্ষা করে দেখুন https://en.wikipedia.org/wiki/Display_aspect_ratio তারপরে আপনি কেবল বিভাগটি করতে পারেন

বাস্তব জীবনের সমস্যার জন্য, আপনি নীচের মতো কিছু করতে পারেন

let ERROR_ALLOWED = 0.05
let STANDARD_ASPECT_RATIOS = [
  [1, '1:1'],
  [4/3, '4:3'],
  [5/4, '5:4'],
  [3/2, '3:2'],
  [16/10, '16:10'],
  [16/9, '16:9'],
  [21/9, '21:9'],
  [32/9, '32:9'],
]
let RATIOS = STANDARD_ASPECT_RATIOS.map(function(tpl){return tpl[0]}).sort()
let LOOKUP = Object()
for (let i=0; i < STANDARD_ASPECT_RATIOS.length; i++){
  LOOKUP[STANDARD_ASPECT_RATIOS[i][0]] = STANDARD_ASPECT_RATIOS[i][1]
}

/*
Find the closest value in a sorted array
*/
function findClosest(arrSorted, value){
  closest = arrSorted[0]
  closestDiff = Math.abs(arrSorted[0] - value)
  for (let i=1; i<arrSorted.length; i++){
    let diff = Math.abs(arrSorted[i] - value)
    if (diff < closestDiff){
      closestDiff = diff
      closest = arrSorted[i]
    } else {
      return closest
    }
  }
  return arrSorted[arrSorted.length-1]
}

/*
Estimate the aspect ratio based on width x height (order doesn't matter)
*/
function estimateAspectRatio(dim1, dim2){
  let ratio = Math.max(dim1, dim2) / Math.min(dim1, dim2)
  if (ratio in LOOKUP){
    return LOOKUP[ratio]
  }

  // Look by approximation
  closest = findClosest(RATIOS, ratio)
  if (Math.abs(closest - ratio) <= ERROR_ALLOWED){
    return '~' + LOOKUP[closest]
  }

  return 'non standard ratio: ' + Math.round(ratio * 100) / 100 + ':1'
}

তারপরে আপনি কেবল কোনও ক্রমে মাত্রাগুলি দিন

estimateAspectRatio(1920, 1080) // 16:9
estimateAspectRatio(1920, 1085) // ~16:9
estimateAspectRatio(1920, 1150) // non standard ratio: 1.65:1
estimateAspectRatio(1920, 1200) // 16:10
estimateAspectRatio(1920, 1220) // ~16:10

Question 19

Width / Height

?