NetFabric.Angle

NetFabric.Angle

Implementa uma estrutura que representa um ângulo.

O ângulo é armazenado na memória na unidade de medida de ângulo em que foi originalmente definido, com dupla precisão, permitindo um controle preciso das conversões e reduzindo erros de arredondamento. Todas as operações são fortemente tipadas.

Inclui operações angulares como lerp, redução, ângulo de referência, comparação, classificação e trigonometria.

Uso:

Adicionando ao seu projeto

NetFabric.Angle está disponível como um pacote NuGet e como um pacote Unity.

Criação do ângulo:

Use os métodos para as unidades de medida com as quais você está trabalhando:

 var right0 = Angle . FromRadian ( Math . PI / 2.0 ) ;
var right1 = Angle . FromDegrees ( 90.0 ) ;
var right3 = Angle . FromGradian ( 100.0 ) ;

Ao usar o formato DMS, minutos de arco e segundos de arco devem ser valores no intervalo [0,0, 60,0[

 var right3 = Angle . FromDegrees ( 90 , 59.9 ) ; // degrees and arcminutes
var right4 = Angle . FromDegrees ( - 90 , 59 , 59.9 ) ; // degrees, arcminutes and arcseconds

Você pode usar os ângulos predefinidos em qualquer unidade de medida:

 var zero = AngleDegrees . Zero ;          // 0 degrees
var right = AngleDegrees . Right ;        // 90 degrees
var straight = AngleDegrees . Straight ;  // 180 degrees
var full = AngleDegrees . Full ;          // 360 degrees 

 var zero = AngleRadians . Zero ;          // 0 radians
var right = AngleRadians . Right ;        // PI/2 radians
var straight = AngleRadians . Straight ;  // PI radians
var full = AngleRadians . Full ;          // 2 * PI radians

Convertendo o ângulo:

Use os métodos static para converter qualquer ângulo:

 var radians = Angle . ToRadians ( angle ) ;

Os ângulos são fortemente digitados para que ele saiba de qual unidade de medida está sendo convertida.

Nota: Se necessário, os resultados devem ser explicitamente reduzidos.

Lendo o ângulo:

Use a propriedade com o nome da unidade de medida (para ser explícito):

 var radians = angleRadians . Radians ;
var degrees = angleDegrees . Degrees ;
var gradians = angleGradians . Gradians ;

Um ângulo em graus pode ser desconstruído na notação DMS. Isso pode ser feito usando argumentos out :

 int degrees0 ;
double minute0 ;
angleDegrees . Deconstruct ( out degrees0 , out minutes0 ) ;

int degrees1 ;
int minute1 ;
double seconds1 ;
angleDegrees . Deconstruct ( out degrees1 , out minutes1 , out seconds1 ) ;

argumentos com sintaxe C# 7:

 angleDegrees . Deconstruct ( out var degrees0 , out var minutes0 ) ;
angleDegrees . Deconstruct ( out var degrees1 , out var minutes1 , out var seconds1 ) ;

ou usando desconstrutores C# 7:

 var ( degrees0 , minutes0 ) = angleDegrees ;
var ( degrees1 , minutes1 , seconds1 ) = angleDegrees ;

Redução e referência

O ângulo pode ser reduzido a um ângulo coterminal no intervalo [0,0, 360,0[graus: ​

 var angle = Angle . Reduce ( AngleDegrees . Right + AngleDegrees . Full ) ; // result is AngleDegrees.Right

Obtendo o ângulo de referência (o menor ângulo com o eixo x):

 var angle = Angle . GetReference ( AngleDegrees . Right + AngleDegrees . FromDegrees ( 45.0 ) ) ; // result is an angle with 45 degrees

Operações matemáticas

Os operadores matemáticos são definidos permitindo cálculos com ângulos. ​

 var angle0 = - AngleDegrees . Right ;
var angle1 = AngleDegrees . Straight + Angle . FromDegrees ( 45.0 ) ;
var angle2 = 2.0 * Angle . FromDegrees ( 30.0 ) ;
var angle3 = Angle . FromDegrees ( 30.0 ) / 2.0 ;

Nota: Se necessário, os resultados devem ser explicitamente reduzidos.

Métodos equivalentes também são definidos para que possam ser usados ​​em linguagens que não suportam operadores.

 var angle0 = Angle . Negate ( AngleDegrees . Right ) ;
var angle1 = Angle . Add ( AngleDegrees . Straight , Angle . FromDegrees ( 45.0 ) ) ;
var angle2 = Angle . Multiply ( 2.0 , Angle . FromDegrees ( 30.0 ) ) ;
var angle3 = Angle . Divide ( Angle . FromDegrees ( 30.0 ) , 2.0 ) ;

Comparação

Operadores de comparação podem ser usados ​​para comparar dois ângulos: ​

 if ( angle0 > angle1 || angle0 == angle2 ) {
    .. .
}

Para linguagens que não suportam operadores, use o método estático Compare(): ​

 if ( Angle . Compare ( angle0 , angle1 ) <= 0 ) { // less or equal to
    .. .
}

Por razões de desempenho, os valores comparados não são reduzidos. Se necessário, eles devem ser explicitamente reduzidos: ​

 if ( Angle . Reduce ( angle0 ) > Angle . Reduce ( angle1 ) ) {
    .. .
}

ou use o método estático CompareReduced():

 if ( Angle . CompareReduced ( angle0 , angle1 ) > 0 ) {
    .. .
}

Trigonometria

As operações usuais de trigonometria (sin, cos, tan, asin, acos, atan, sinh e cosh) estão disponíveis como métodos estáticos, mas apenas para ângulos em radianos:

 double value0 = Angle . Sin ( angleRadians ) ;
AngleRadians angle0 = Angle . Asin ( value0 ) ;

Os ângulos que não estão em radianos devem ser convertidos:

 double value1 = Angle . Sin ( Angle . ToRadians ( angleDegrees ) ) ;
AngleDegrees angle1 = Angle . ToDegrees ( Angle . Asin ( value1 ) ) ;

Classificação

Você pode obter o quadrante do ângulo

 var quad0 = Angle . GetQuadrant ( Angle . FromDegrees ( 45.0 ) ) ; // Angle.Quadrant.First
var quad1 = Angle . GetQuadrant ( Angle . FromDegrees ( 220.0 ) ) ; // Angle.Quadrant.Third
var quad2 = Angle . GetQuadrant ( Angle . FromDegrees ( - 45.0 ) ) ; // Angle.Quadrant.Fourth

e pode verificar se um ângulo é agudo, reto, obtuso, reto ou reflexo:

 var isAcute = Angle . IsAcute ( AngleDegrees . Right ) ; // false
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 45.0 ) ) ; // true
var isRight = Angle . IsRight ( AngleDegrees . Right ) ; // true

A classificação considera o equivalente positivo reduzido do ângulo assim:

 var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 45.0 ) ) ; // true
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( - 45.0 ) ) ; // true
var isAcute = Angle . IsAcute ( Angle . FromDegrees ( 315.0 ) ) ; // false