从面积和角度计算三角形

问题描述 投票：1回答：6

我正在尝试根据面积和角度计算三角形。如果Angle-B是90°那么公式可以工作，但在我的情况下，角度可以是0.1°到179.8°。该公式假设角度为90，所以我认为可能存在一些隐藏的东西可能非常适合角度。这是公式：

alt text alt text

代码中的公式是：

Height = sqrt((2 * Area) / (tan(Angle-A)));

我正在寻找公式的后半部分。公式的下一部分是这样的：

cos(sin(AngleB))
math trigonometry calculus
6个回答
6
投票

好吧，新尝试：如果我的计算是正确的，那么B面等于sqrt（2 *面积* sin（角度-B）/（sin（角度-A）* sin（角度-C））

由于Area = 1/2 * A * B * sin（c）= 1/2 * C * B * sin（a）= 1/2 * A * C * sin（b）我们得到：

A = 2 * area /（B * sin（c））并使用此我们得到：

C = sin（c）* B / sin（b），当我们将它放回到区域方程中时，我们得到：

B = sqrt（2 *面积* sin（角度-B）/（sin（角度-A）* sin（角度-C））

当您知道一侧和所有角度时，使用普通三角法计算其他边应该很容易。

6
投票

tziki的答案是正确的，但我想详细说明它是如何得出的。

我们从角度和面积开始作为知识。我将使用OP图中的标签来解释这个问题。

首先，我们有一个基本的事实，即三角形的面积是其基部和高度的一半：Area = base * height / 2。我们希望能够确定基数和高度之间的关系，这样我们就可以将这个方程式减少到一个未知数并求解基数。

另一个重要的事情是三角形的高度与Side-A：height = Side-A * sin(Angle-B)成正比。所以知道Side-A会给我们带来高度。

现在我们需要在Side-A和Side-C（基础）之间建立关系。这里最合适的规则是正弦律：Side-A/sin(A) = Side-C/sin(C)。我们重新安排这个等式，以Side-C：Side-A = Side-C * sin(A)/sin(C)的形式找到Side-A。

我们现在可以将此结果插入到高度方程式中，以获得仅以Side-C表示的高度公式：height = Side-C * sin(A) * sin(B) / sin(C)

使用Side-C作为面积方程的基础，我们现在可以仅用Side-C找到该区域：Area = Side-C^2 * sin(A) * sin(B) / 2sin(C)

然后重新安排这个等式，以区域的形式找到Side-C：

Side-C = SQRT(2 * Area * sin(C) / (sin(B) * (sin(A)))

这给你一个方面。这可以重复以找到其他方面，或者您可以使用不同的方法来找到知道这一方的其他方。

2
投票

你已经有了自己的答案，但我不得不在前一段时间内为求职面试解决这种问题。这并不难，并没有花太多时间来达到以下解决方案。

阅读它，它应该是自我解释的。

创建一个Python模块，通过应用正弦和余弦定理来解决三角形。

模块接收一些三角形值作为参数，并且如果可能，返回其所有角度和边长的值。

参数作为dict接收，它应该能够从命令行独立调用。

from __future__ import division
import sys, logging
from math import radians, degrees, acos, cos, sin, sqrt, asin

class InconsistentDataError(TypeError):
    pass


class InsufficientDataError(TypeError):
    pass


class NonUpdatable(dict):
    """Dictionary whose items can be set only once."""
    def __setitem__(self, i, y):
        if self.get(i, None):
            raise InconsistentDataError()
        super(NonUpdatable, self).__setitem__(i, y)


def get_known_sides(**kwarg):
    """Filter from the input elements the Side elements."""
    return dict([i for i in kwarg.iteritems() if i[0].isupper()])

def get_known_angles(**kwarg):
    """Filter from the input elements the Angle elements."""
    return dict([i for i in kwarg.iteritems() if i[0].islower()])

def get_opposite_angle(C, B, A):
    """
    Get the angle corresponding to C.

    Keyword arguments:
    A -- right side of the angle (real number > 0)
    B -- left side of the angle (real number > 0)
    C -- side opposite to the angle (real number > 0)

    Returns:
    angle opposite to C
    """
    return degrees(acos((A**2 + B**2 - C**2) / (2 * A * B)))

def get_side(A, B, c):
    """
    Calculate the Side corresponding to the Angle c.

    Keyword arguments:
    A -- left side of C (real number > 0)
    B -- right side of C (real number > 0)
    c -- angle opposite to side C (real number)

    Returns:
    side C, opposite to c
    """
    return sqrt(A**2 + B**2 - 2*A*B*cos(radians(c)))

def get_overlapping_angle(known_angles, known_sides):
    """
    Calculate the Angle of a known side, knowing the angle to another known side.

    Keyword arguments:
    known_angles -- (dict of angles)
    known_sides -- (dict of sides)

    Returns:
    angle of the known side, to which there is no known angle
    """
    a = (set([i.lower() for i in known_sides.iterkeys()]) - 
            set([i.lower() for i in known_angles.iterkeys()])).pop()

    b = (set([i.lower() for i in known_sides.iterkeys()]) & 
            set([i.lower() for i in known_angles.iterkeys()])).pop()

    y = (known_sides[a.upper()]/known_sides[b.upper()]) * sin(radians(known_angles[b.lower()]))
    if y > 1: y = 1 #Rounding error fix --- y = 1.000000000001; asin(y) -> Exception
    return {a.lower(): degrees(asin(y))}

def get_angles(A, B, C):
    """
    Calculate all the angles, given the length of all the sides.

    Keyword arguments:
    A -- side A (real number > 0)
    B -- side B (real number > 0)
    C -- side C (real number > 0)

    Returns:
    dict of angles
    """
    sides = {"A":A,"B":B,"C":C}
    _sides = sides.keys()
    angles = {}

    for side in sides.keys():
        angles[side.lower()] = get_opposite_angle(
                                    sides[_sides[0]], 
                                    sides[_sides[1]], 
                                    sides[_sides[2]])
        _sides.append(_sides.pop(0))

    return angles

def get_triangle_values(**kwargs):
    """Calculate the missing values of a triangle based on the known values."""
    known_params = kwargs
    angles = NonUpdatable({
        "a":0, 
        "b":0, 
        "c":0,
    })
    sides = NonUpdatable({
        "A":0, 
        "B":0, 
        "C":0,
    })

    if len(known_params) < 3:
        raise InsufficientDataError("Three parameters are needed to calculate triangle's values.")

    if str(known_params.keys()).islower():
        raise TypeError("At least one length needed.")

    known_sides = NonUpdatable(get_known_sides(**known_params))
    sides.update(known_sides)
    known_angles = NonUpdatable(get_known_angles(**known_params))
    angles.update(known_angles)

    if len(known_angles) == 3 and sum(known_angles.itervalues()) != 180:
        raise InconsistentDataError("One of the sides is too long.")

    if len(known_sides) == 3:
        x=[side for side in known_sides.itervalues() if (sum(known_sides.itervalues()) - side) < side]
        if len(x):
            raise InconsistentDataError("One of the sides is too long.")

        for angle, value in get_angles(**known_sides).iteritems(): 
            # Done this way to force exception when overwriting a 
            # user input angle, otherwise it would be a simple assignment.
            # >>> angles = get_angles(**known_sides)
            # This means inconsistent input data.
            angles[angle] = value

    else: # There are angles given and not enough sides.
        if len(known_angles) > 1:
            #2 angles given. Get last angle and calculate missing sides
            for angle, val in angles.iteritems():
                if val == 0:
                    angles[angle] = 180. - sum(angles.itervalues())

            known_sides = known_sides.items()
            for side, length in sides.iteritems():
                if length == 0:
                    sides[side] = known_sides[0][1] / \
                        sin(radians(angles[known_sides[0][0].lower()])) * \
                        sin(radians(angles[side.lower()]))

        else:
            unknown_side = (set(sides.keys()) - set(known_sides.keys())).pop()

            chars = [ord(i.lower()) for i in known_params.iterkeys()]
            chars.sort()

            if chars[0] < chars[1] < chars[2]:
                sides[unknown_side] = get_side(known_sides.values()[0], known_sides.values()[1], known_angles[unknown_side.lower()])
                angles = get_angles(**sides)

            else:
                known_angles.update(get_overlapping_angle(known_angles, known_sides))
                angles.update(known_angles)

                for angle, val in angles.iteritems():
                    if val == 0:
                        angles[angle] = 180. - sum(angles.itervalues())

                sides[unknown_side] = get_side(known_sides.values()[0], known_sides.values()[1], angles[unknown_side.lower()])

    angles.update(sides)
    return angles

if __name__ == "__main__":
    try:
        values = get_triangle_values( **eval(sys.argv[1], {}, {}) )
    except IndexError, e:
        values = get_triangle_values(A=10,B=10,C=10)
    except InsufficientDataError, e:
        print "Not enough data!"
        exit(1)
    except InconsistentDataError, e:
        print "Data is inconsistent!"
        exit(1)

    print values

A，B和C是边长，a，b和c是角度，因此c是与C侧相反的角度。

Tests

0
投票

如何计算三角形的两边长度，其中第三个尺寸的长度为1（在角度上使用law of sines，长度为1），然后缩放三角形直到其面积与您的面积相匹配有？然后你可以很容易地计算出身高。 http://en.wikipedia.org/wiki/Triangle_area#Using_trigonometry

0
投票

如果我没有弄错，两个角度a和b之间的边x的长度应该如下。

         ________________
        /  2A       2A
x =    / ------ + ------
     \/  tan(a)   tan(b)

所以要计算边C，但是在角度A和角度B。

（现在仔细检查它 - 似乎是正确的。）

0
投票

如果三角形是等腰，你给Side-A的公式似乎是正确的，即Angle-B = Angle-C（你可以使用正弦定律和该区域的正弦公式得到这个）。如果它不是等腰，你似乎需要知道其他角度;通用公式是：

Side-A = sqrt(2*Area*sin(Angle-A)/(sin(Angle-B)*sin(Angle-C)))

当然，我是在脑子里做的，所以检查数学;）

编辑：好的，在签入纸张后修改公式。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.