Obliczenie azymutu ze współrzędnych – wersja C++ Builder

Obliczenie azymutu ze współrzędnych – wersja C++ Builder
Specyfikacja problemu algorytmicznego
Problem algorytmiczny: Obliczenie azymutów i długości, gdy dana jest tablica współrzędnych punktów (Nr X Y).
Dane wejściowe:
Tablica numerów i współrzędnych punktów (numery – liczby całkowite, współrzędne X, Y typu double)
Dane wyjściowe: długości boków, azymuty wektorów Pi-Pi+1 - w gradach, stopniach (liczba jako dziesiętne stopnia),
stopnie całkowite, minuty i sekundy oraz azymut odwrotny wektora Pi+1-P1 – wyświetlone na ekranie formularza
obliczeniowego (wersja obiektowa – C++ Builder) .
Szkic do obliczeń azymutu:
Wzory:
Odległość:
d=sqrt(Dx*Dx+Dy*Dy);
Tradycyjnie – obliczenia ręczne - dodatkowo liczy się:
d=DX/cos(Az); d=DY/sin(Az);
Azymut
Zastosowano w programie funkcję atan2(dy,dx), gdzie dx, dy – przyrosty współrzednych
az2 = atan2(Dy, Dx) – funkcja biblioteczna języka C
Opis programu
Program napisano i skompilowano w z wykorzystaniem aplikacji Borland C++ Builder 6 Personal.
1. Formularz programu zawiera blok DANE – komponent StringGrid - tabela do wprowadzenia numerów współrzędnych
punktów, suwak do wprowadzenia ilości wierszy - komponent ScrollBar , komponent Edit – wyświetla ilość wierszy,
komponenty Label – etykiet opisowe (napisy) oraz przyciski: do wypełnienia tabeli zerami, do uruchomienia obliczeń: i
przycisk wyjścia z programu.
2. Po uruchomieniu programu pojawia się Formularz, na nim 2 wiersze do wprowadzenia ilości wierszy (punktów).
Ilość te można zmienić przy pomocy suwaka. Naciśnięcie klawisza KONIEC powoduje wyjście z programu.
2. W pola Nr X Y należy wpisać odpowiednie dane. Naciśnięcie przycisku Wypelnij lub Oblicz wypełnia puste pola zerami.
3. Po naciśnięciu przycisku Oblicze obliczane są azymuty i długości oraz wyświetlane na ekranie.
4. Azymuty są obliczane przy pomocy funkcji atan2(dy,dx) i zamieniane na grady oraz miarę stopniową.
Przykład obliczeń – kopia ekranu
Funkcje obliczeniowe wykorzystywane w programie:
// Funkcje - deklaracje
double odl(double x1, double y1, double x2, double y2); // odległość ze współrzędnych
double az2(double x1, double y1, double x2, double y2); // azymut z funkcji atan2
Schematy blokowe funkcji obliczenia azymutów
Funkcja az2(x1, y1, x2, y2) – zastosowanie atan2(dy,dx)
Listingi programu
Plik azdlCB1.h
//--------------------------------------------------------------------------// Obliczenie azymutu i długości ze współrzędnych - Borland C++ Builder 6
// Plik azdlCB1.h
// 02.2012
// K. R.
// definicja maks ilosc wierszy
#define NMAX 20
#include <math.h>
#include <Classes.hpp>
#include <Controls.hpp>
#include <ExtCtrls.hpp>
#include <Grids.hpp>
#include <StdCtrls.hpp>
#ifndef azdlCB1H
#define azdlCB1H
//--------------------------------------------------------------------------#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
// Deklaracja funkcji
double dl(double dx, double dy); // obl. dlugosci
//--------------------------------------------------------------------------// Komponenty formularza
class TForm1 : public TForm
{
__published:
// IDE-managed Components
TPanel *Panel1;
TButton *Koniec;
TStringGrid *Dane;
TScrollBar *Wiersze;
TEdit *IloscWierszy;
TButton *Oblicz;
TLabel *Label1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label4;
TLabel *Label5;
TLabel *Label6;
TLabel *Label7;
TLabel *Label8;
TLabel *Label9;
TLabel *Label10;
TLabel *Label11;
TLabel *Label12;
TButton *Wypelnij;
TLabel *Label13;
TLabel *Label14;
TLabel *Label15;
TLabel *Label16;
TLabel *Label17;
TLabel *Label18;
void __fastcall KoniecClick(TObject *Sender);
void __fastcall WierszeChange(TObject *Sender);
void __fastcall ObliczClick(TObject *Sender);
void __fastcall FormCreate(TObject *Sender);
void __fastcall WypelnijClick(TObject *Sender);
// sekcja private - deklaracje uzytkownika
private: // User declarations
int m, n;
int tN[NMAX];
double tX[NMAX], tY[NMAX], tDX[NMAX], tDY[NMAX], tD[NMAX], tA[NMAX];
// Sekcja public
public:
// User declarations
__fastcall TForm1(TComponent* Owner);
// Definicja funkcji dl() - obliczenie dlugosci z przyrostow dx, dy
double dl(double dx, double dy)
{
return sqrt(dx*dx+dy*dy);
}
};
//--------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;
//--------------------------------------------------------------------------#endif
plik P_AzDCB1.cpp
//--------------------------------------------------------------------------//Projekt - plik P_AzDCB1.cpp
// azymut i długość ze współrzędnych - wersja C++ Builder
// Program główny
#include <vcl.h>
#pragma hdrstop
//--------------------------------------------------------------------------USEFORM("azdlCB1.cpp", Form1);
//--------------------------------------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
Application->Initialize();
Application->CreateForm(__classid(TForm1), &Form1);
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
catch (...)
{
try
{
throw Exception("");
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
}
return 0;
}
//---------------------------------------------------------------------------
Plik azdlCB1.cpp
//--------------------------------------------------------------------------// Plik azdlCB1.cpp
// Obliczenie azymutu i długości ze współrzędnych
// Borland C++ Builder 6
#include <vcl.h>
#pragma hdrstop
#include "azdlCB1.h"
// Deklaracje funkcji
// double dl(double dx, double dy); - jest w azdlCB1.h
double az2(double dx, double dy);
int grad2dg(double gr);
int grad2min(double gr);
float grad2sek(double gr);
//--------------------------------------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//--------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//--------------------------------------------------------------------------void __fastcall TForm1::KoniecClick(TObject *Sender)
{
Close();
}
//--------------------------------------------------------------------------void __fastcall TForm1::WierszeChange(TObject *Sender)
// Zmiana wierszy - komponent ScrollBar - listwa przewijania
{
Dane->RowCount=Wiersze->Position;
n=Wiersze->Position;
IloscWierszy->Text=n;
}
//--------------------------------------------------------------------------void __fastcall TForm1::ObliczClick(TObject *Sender)
// Obliczenie
{
double dx, dy, d, azg1, azg2, degree;
int stop, min, sek;
// wypelnienie tabeli zerami
// wypelnij
for (int i=0; i<=n; i++)
{
for (int j=0; j<=2; j++)
if (Dane->Cells[j][i]=="")
Dane->Cells[j][i]=0;
} // wypelnij
// Obliczenia
// wprowadzenie danych do tabel z komponentu StringGrid - tabela na ekranie
for (int i=0; i<n; i++)
{
tN[i]= StrToInt (Dane->Cells[0][i]);
tX[i]= StrToFloat(Dane->Cells[1][i]);
tY[i]= StrToFloat(Dane->Cells[2][i]);
}
for (int i=0; i<n-1; i++)
{
// przyrosty
tDX[i]= StrToFloat(Dane->Cells[1][i+1])- StrToFloat(Dane->Cells[1][i]);
tDY[i]= StrToFloat(Dane->Cells[2][i+1])- StrToFloat(Dane->Cells[2][i]) ;
d=dl(tDX[i],tDY[i]); // dlugosc
azg1=az2(tDX[i], tDY[i]); // azymut w grad
tD[i]=d; // dlugosc do tabeli
tA[i]=azg1;
degree=azg1*0.9; // azymut w stopniach i dzies. stopnia
azg2=az2(-tDX[i], -tDY[i]); // azymut odwrotny w [grad]
// wypelnienie tabeli na ekranie
Dane->Cells[3][i]=tDX[i];
Dane->Cells[4][i]=tDY[i];
Dane->Cells[5][i]=d;
Dane->Cells[6][i]=azg1;
Dane->Cells[7][i]=degree;
Dane->Cells[8][i]=grad2dg(azg1);
Dane->Cells[9][i]=grad2min(azg1);
Dane->Cells[10][i]=grad2sek(azg1);
Dane->Cells[11][i]=azg2;
// W ostatniej linii wypelnienie pustymi elemantami
for (int j=0; j<=11; j++)
Dane->Cells[j][n]="";
} // for
}
//--------------------------------------------------------------------------// po utworzeniu formularza
void __fastcall TForm1::FormCreate(TObject *Sender)
{
int const NK=12;
Dane->ColCount=NK;
Dane->RowCount=2;
n=2;
m=12;
}
//--------------------------------------------------------------------------// wypełnienie danymi tabeli ekranowej
void __fastcall TForm1::WypelnijClick(TObject *Sender)
{
for (int i=0; i<=n; i++)
{
for (int j=0; j<=2; j++)
Dane->Cells[j][i]=0;
}
}
//--------------------------------------------------------------------------// Funkcje - definicje
// obliczenie azymutu z atan2(dy,dx)
double az2(double dx, double dy)
{
double a;
if (dx==0 && dy==0) return 0;
a = atan2(dy,dx) * 200.0/M_PI;
if (a <0) a += 400.0;
return a;
}
// zamiana gradów na stopnie całkowite - zwraca tylko stopnie
int grad2dg(double gr)
{
double st, mi;
int sc;
st=gr*0.9; // stopnie
sc= int(st); // stopnie calkowite
return sc;
}
// zamiana gradów na stopnie - zwraca tylko minuty całkowite
int grad2min(double gr)
{
double st, mi;
int sc, mc;
st=gr*0.9; // stopnie
sc= int(st); // stopnie calkowite
mi=(st-sc)*60.0; // minuty
mc=int(mi); // minuty calkowite
// se=(mi-mc)*60.0; // sekundy
return mc;
}
// zamiana gradów na stopnie - zwraca stopnie - zwraca tylko sekundy, liczba rzeczywista
float grad2sek(double gr)
{
double st, mi, se;
int sc, mc;
st=gr*0.9; // stopnie
sc= int(st); // stopnie calkowite
mi=(st-sc)*60.0; // minuty
mc=int(mi); // minuty calkowite
se=(mi-mc)*60.0; // sekundy
return se; // zwraca sekundy
}