Mając współrzędne punktów bryły w układzie



Pobieranie 63.31 Kb.
Data02.05.2016
Rozmiar63.31 Kb.
Obrót

Mając współrzędne punktów bryły w układzie (x, y, z) związanym z wirującą bryłą chcemy określić zmieniające się współrzędne punktów bryły w układzie nieruchomym (x0 , y0 , z0). Obrót wokół osi z pokazano na rys. 2.1.



Tworzymy zamknięty wielobok wektorów (rys.2.1b). Żądając aby wypadkowa wektorów

była równa zeru znajdujemy współrzędne w układzie nieruchomym

Podobnie możemy znaleźć współrzędne punktów bryły po obrocie wokół osi x oraz y.

Macierze obrotu Q wokół osi x, y i z
, , ..
Mając współrzędnie w układzie n oraz wzajemnie położenia układów znajdujemy współrzędne

w układzie 0



Macierze T



, , .

(12)


//CPP rzut

//---------------------------------------------------------------------------


#include

#pragma hdrstop

#include

#include "rzut1.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

}



bool inputstate;

typedef long double XYZReal[10000][4] ;

XYZReal XYZ;

void Rot(int ilp,int axis,long double kat,long double x0,long double y0,long double z0,XYZReal &XYZ)

{

long double c,s,x,y,z;



int i;

c= cos(kat);s= sin(kat);

switch(axis){

case 1: for( i= 1; i<=ilp; i++)

{y=XYZ[i][2]-y0;z=XYZ[i][3]-z0;XYZ[i][2]= y*c-z*s+y0;XYZ[i][3]= y*s+z*c+z0; } break;

case 2: for( i= 1; i<=ilp; i++)

{x=XYZ[i][1]-x0; z=XYZ[i][3]-z0;XYZ[i][1]= x*c+z*s+x0;XYZ[i][3]= z*c-x*s+z0; }break;

case 3: for( i= 1; i<=ilp; i++)

{ x=XYZ[i][1]-x0; y=XYZ[i][2]-y0;XYZ[i][1]= x*c-y*s+x0;XYZ[i][2]= x*s+y*c+y0;}

}

}


int ilp=15;

long double Dane[16][3]=

{{0,0,0},

{1,0,0},


{1,2,0},

{0,2,0},


{0,0,0},

{0,0,3},


{1,0,3},

{1,2,3},


{0,2,3},

{0,0,3},


{1,0,0},

{1,0,3},


{1,2,0},

{1,2,3},


{0,2,0},

{0,2,3}};


long double pi=4.0*atan(1.0);

Graphics::TBitmap *Obraz = new Graphics::TBitmap;


void TForm1 :: Line(int x1,int y1,int x2,int y2)

{ Obraz->Canvas->MoveTo(x1,y1);Obraz->Canvas->LineTo(x2,y2); }


void TForm1 :: DrawPolyg(int point1,int NumPoints, WspXY Wsp)

{ int i;


for (i= point1; i<=NumPoints-1; i++) Line(Wsp[i][1],Wsp[i][2],Wsp[i+1][1],Wsp[i+1][2]);

}
void __fastcall TForm1::Button1Click(TObject *Sender)

{

Obraz->Height= ClientHeight; // msza byc okreslone wymiary



Obraz->Width= ClientWidth;
WspXY Wsp ;

long double Skala,Alx,Aly,Alz;

int i;

Skala=100;Alx=pi/90.0;Aly=pi/90.0;Alz=pi/90;


for( i= 0; i<=ilp; i++)

{

XYZ[i+1][1]=Dane[i][0]*Skala;



XYZ[i+1][2]=Dane[i][1]*Skala;

XYZ[i+1][3]=Dane[i][2]*Skala;

}
Obraz->Canvas->Pen->Width=2;

Obraz->Canvas->Pen->Color=clRed;


while (true)

{
Rot(ilp+1,1,Alx,0,0,0,XYZ); Rot(ilp+1,2,Aly,0,0,0,XYZ); Rot(ilp+1,3,Alz,0,0,0,XYZ);


for( i= 1; i<=ilp+1; i++)

{

Wsp[i][1]= int(XYZ[i][1])+100;



Wsp[i][2]= int(XYZ[i][2])+100;

}

Obraz->Canvas->Brush->Color=clWhite; Obraz->Canvas->Rectangle(0,0,Screen->Width,Screen->Height);


DrawPolyg(1,10,Wsp); DrawPolyg(11,12,Wsp);

DrawPolyg(13,14,Wsp); DrawPolyg(15,16,Wsp);

Sleep(50);

Form1->Canvas->Draw(0,0, Obraz);

inputstate = GetInputState( ); if (inputstate == true) break ;

}
Close();

}

Header


//---------------------------------------------------------------------------
#ifndef rzut1H

#define rzut1H

//---------------------------------------------------------------------------

#include

#include

#include

#include

//---------------------------------------------------------------------------

class TForm1 : public TForm

{

__published: // IDE-managed Components



TButton *Button1;

void __fastcall Button1Click(TObject *Sender);

private: // User declarations

public: // User declarations

__fastcall TForm1(TComponent* Owner);

void Line(int x1,int y1,int x2,int y2);

typedef int WspXY[10000][3] ;

void DrawPolyg(int point1,int NumPoints, WspXY Wsp);

};

//---------------------------------------------------------------------------



extern PACKAGE TForm1 *Form1;

//---------------------------------------------------------------------------

#endif

//---------------------------------------------------------------------------

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Delphi


const ilp=16;

Dane:array[1..ilePunt,1..3] of real=

((0,0,0), (1,0,0), (1,2,0), (0,2,0), (0,0,0), (0,0,3), (1,0,3),(1,2,3),

(0,2,3), (0,0,3), (1,0,0), (1,0,3), (1,2,0), (1,2,3), (0,2,0), (0,2,3));

for i:=1 to ilp do

begin ii:=ii+1;

XYZ^[ii,1]:=Dane[ii,1]*Skala;

XYZ^[ii,2]:=Dane[ii,2]*Skala;

XYZ^[ii,3]:=Dane[ii,3]*Skala;

end; il:=ii;

Repeat

Rot(il,1,Alx,0,0,0,XYZ); Rot(il,2,Aly,0,0,0,XYZ); Rot(il,3,Alz,0,0,0,XYZ);



for i:=1 to il do

begin


Wsp[i,1]:=round(XYZ[i,1])+100;

Wsp[i,2]:=round(XYZ[i,2])+200;

end;

SetColor(red);



DrawPolyg(1,10,Wsp); DrawPolyg(11,12,Wsp);

DrawPolyg(13,14,Wsp); DrawPolyg(15,16,Wsp);

For i :=1 to 1000 do Delay(20000);

SetColor(white);

DrawPolyg(1,10,Wsp); DrawPolyg(11,12,Wsp);

DrawPolyg(13,14,Wsp); DrawPolyg(15,16,Wsp);

until GetInputState;

Przekroje brył


Linia przekroju bryły płaszczyzną jest zbiorem punktów należących równocześnie do powierzchni bryły i do płaszczyzny. Tworzymy układ równań złożony z równań płaszczyzny oraz równań określających powierzchnię boczną bryły. Współrzędne punktów linii przekroju znajdujemy jako rozwiązanie tak otrzymanego układu równań. Takie postępowanie zilustrowane będzie na przykładzie przekroju stożka płaszczyzną.

Powierzchnia stożkowa jako suma okręgów (a) o zmiennym promieniu (b) przecięta płaszczyzną tnąca (c).

Powierzchnia stożkowa może być potraktowana jako suma okręgów określonych równaniami



Zmienny promień dany jest zależnością

Równanie płaszczyzny tnącej ma postać




Rozwiązując powyższy układ równań znajdujemy współrzędne punktów linii przekroju jak funkcje parametru .




Przyjmując kolejne wartości parametru znajdujemy współrzędne x, y oraz z linii przekroju

Linię przekroju obracamy w przestrzeni. Niżej xyz dla =(i/9;0.9910.85

oraz podstawa stożka)

//PASCAL


Przekrój stożka

Program PrzeST1;

uses Graph,printer,tooll,Funct;

const ilm=500;

var LineStyle,Pattern,Thickness: word;

Gd, Gm,ilo,ilw,il,ii,i,j,MaxX,MaxY,CEx,CEy:integer;

{dz,z,Skala,}Al,Dal,r,H,bet,fi,x0,z0:real;

{$I c:\mmw\RotPoly.PAS}

VAR XYZ:PXYZReal; Wsp:PWspXY;

Begin


Gd := Detect; InitGraph(Gd, Gm, '');

new(XYZ);new(WSP);

MaxX:=GetmaxX;MaxY:=GetMaxY; CEx:=maxX div 2;CEy:=maxY div 2;

{***********okrag - podstawa walca************************}

ilo:=40; Dal:=2*pi/(ilo-1); r:=100; H:=400;

fi:=arctan(r/H); bet:={pi/2*0.99;}{pi/9;}{fi*0.991;}fi*0.85;

x0:=0.0; z0:=H/4;

Al:=0;ii:=0;

for i:=1 to ilo do

begin


ii:=ii+1; Al:=AL+Dal;

XYZ^[ii,1]:=R*COS(aL); XYZ^[ii,2]:=r*SIN(AL); XYZ^[ii,3]:=H;

end; il:=ii;

{****************linia przekroju***************************}

Al:=0;

for i:=1 to ilo do



begin

ii:=ii+1; Al:=AL+Dal;

XYZ^[ii,3]:=(z0-x0/tan(bet))/(1-tan(fi)*cos(al)/tan(bet));

XYZ^[ii,1]:=XYZ^[ii,3]*cos(aL)*tan(fi);

XYZ^[ii,2]:=XYZ^[ii,3]*sin(aL)*tan(fi);

end;


il:=ii;

{Rot(il,1,0,0,0,0,XYZ);

Rot(il,2,0,0,0,0,XYZ);

Rot(il,3,0,0,0,0,XYZ);}

for i:=1 to il do

begin


Wsp^[i,1]:=round(XYZ^[i,1])+CEx; Wsp^[i,2]:=round(XYZ^[i,2])+CEy;

end;


SetBkColor(blue); SetColor(white);

(*LineStyle:=SolidLn; {DottedLn;CenterLn;DashedLn;}

Pattern:=0;

Thickness:=NormWidth; {ThickWidth;}

SetLineStyle(LineStyle,Pattern,Thickness);*)

DrawPolyg(1,ilo,Wsp); DrawPolyg(ilo+1,ilo+ilo,Wsp);

Readln; CloseGraph; dispose(XYZ);dispose(WSP);

End.

Linia przenikania brył


Linia przenikania dwóch brył jest zbiorem punktów należących równocześnie do powierzchni obydwu brył. Współrzędne punktów linii przenikania znajdujemy jako rozwiązanie układu równań złożonego z równań określających powierzchnie boczne obydwu brył. Takie postępowanie zilustrowane będzie na prostym przykładzie linii przenikania walców.

Walce których linia przenikania ma być wyznaczona.

Równanie powierzchni bocznej walca pionowego

Równanie powierzchni bocznej walca poziomego


Podstawiając kolejne wartości z znajdujemy współrzędne punktów linii przenikania brył





Linię przenikania obracamy w przestrzeni.

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

PASCAL


Program Przenik0;

uses Graph,Printer,tooll,Funct; const ilm=2000;

var Gd, Gm,ilw,il,ii,i,j,MaxX,MaxY:integer;

r1,r2,dz,z{,Skala}:real;


{$I c:\mmw\RotPoly.PAS}

var


XYZ:PXYZReal; Wsp:PWspXY;

BEGIN


Gd := Detect;InitGraph(Gd, Gm, '');

new(XYZ);new(WSP);

MaxX:=GetmaxX;MaxY:=GetMaxY; { skala:=100;}

r1:=40;r2:=50;ilw:=100;dz:=2*50.0/(ilw-1);

ii:=0;

{*****************linia przenikania walcow**********************}



z:=-r2;

for i:=1 to ilw do

begin

if (abs(z)<=r2) and (abs(z)<=r1) then



begin

ii:=ii+1;

XYZ^[ii,1]:=sqrt(r1*r1-z*z);

XYZ^[ii,2]:=sqrt(r2*r2-z*z);

XYZ^[ii,3]:=z;

end;


z:=z+dz;

end;il:=ii;

{***************************************************************}

Rot(il,1,pi/9,MaxX div 2,MaxY div 2,0,XYZ);

Rot(il,2,Pi/18,MaxX div 2,MaxY div 2,0,XYZ);

Rot(il,3,0,0,0,0,XYZ);

for i:=1 to il do

begin


Wsp^[i,1]:=round(XYZ^[i,1])+maxX div 2;

Wsp^[i,2]:=round(XYZ^[i,2])+maxY div 2;

end;

SetBkColor(blue); SetColor(white);



DrawPolyg(1,il,Wsp);

Readln;CloseGraph;

dispose(XYZ);dispose(WSP);

END.


>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

PASCAL


Pełny rysunek
Program Przenika; uses Graph,printer,tooll,Funct; const ilm=2000;

var


LineStyle,Pattern,Thickness:word;

Gd, Gm,ilo,ilw,il,il1,il2,il3,il4,ii,i,j,MaxX,MaxY:integer;

r1,r2,dz,z,Skala,Al,Dal,r:real;

{$I c:\mmw\RotPoly.PAS}

VAR XYZ:PXYZReal; Wsp:PWspXY;

BEGIN


Gd := Detect;InitGraph(Gd, Gm, '');

MaxX:=GetmaxX;MaxY:=GetMaxY; skala:=100;ii:=0;

new(XYZ);new(WSP);

{********************walce**************************************}

r1:=40;r2:=50;ilw:=100;dz:=2*50.0/(ilw-1);

ilo:=20;Dal:=2*pi/(ilo-1);Al:=0;

for i:=1 to ilo do

begin


ii:=ii+1; Al:=AL+Dal;

XYZ^[ii,2]:=R2*COS(aL); XYZ^[ii,3]:=R2*SIN(AL); XYZ^[ii,1]:=4*R2;

end; il:=ii;Al:=0;

for i:=1 to ilo do

begin

ii:=ii+1; Al:=AL+Dal;



XYZ^[ii,2]:=R2*COS(aL); XYZ^[ii,3]:=R2*SIN(AL); XYZ^[ii,1]:=-4*R2;

end; Al:=0;

for i:=1 to ilo do

begin


ii:=ii+1; Al:=AL+Dal;

XYZ^[ii,1]:=R1*COS(aL); XYZ^[ii,3]:=R1*SIN(AL); XYZ^[ii,2]:=4*R1;

end; Al:=0;

for i:=1 to ilo do

begin

ii:=ii+1;



Al:=AL+Dal;

XYZ^[ii,1]:=R1*COS(aL); XYZ^[ii,3]:=R1*SIN(AL); XYZ^[ii,2]:=-4*R1;

end;

{*****************linia przenikania walcow**********************}



z:=-r2;

for i:=1 to ilw do

begin

if (abs(z)<=r2) and (abs(z)<=r1) then



begin

ii:=ii+1;

XYZ^[ii,1]:=sqrt(r1*r1-z*z); XYZ^[ii,2]:=sqrt(r2*r2-z*z); XYZ^[ii,3]:=z;

end;


z:=z+dz;

end;il1:=ii;

for i:=1 to ilw do

begin


if (abs(z)<=r2) and (abs(z)<=r1) then

begin


ii:=ii+1;

XYZ^[ii,1]:=sqrt(r1*r1-z*z); XYZ^[ii,2]:=-sqrt(r2*r2-z*z); XYZ^[ii,3]:=z;

end;

z:=z-dz;


end;il2:=ii;z:=-r2;

for i:=1 to ilw do

begin

if (abs(z)<=r2) and (abs(z)<=r1) then



begin

ii:=ii+1;

XYZ^[ii,1]:=-sqrt(r1*r1-z*z); XYZ^[ii,2]:=sqrt(r2*r2-z*z); XYZ^[ii,3]:=z;

end;


z:=z+dz;

end;il3:=ii;

for i:=1 to ilw+1 do

begin


if (abs(z)<=r2) and (abs(z)<=r1) then

begin


ii:=ii+1;

XYZ^[ii,1]:=-sqrt(r1*r1-z*z); XYZ^[ii,2]:=-sqrt(r2*r2-z*z); XYZ^[ii,3]:=z;

end;

z:=z-dz;


end;il:=ii;il4:=ii;

Rot(il,1,pi/9,MaxX div 2,MaxY div 2,0,XYZ);

Rot(il,2,Pi/18,MaxX div 2,MaxY div 2,0,XYZ);

Rot(il,3,0,0,0,0,XYZ);

for i:=1 to il do

begin


Wsp^[i,1]:=round(XYZ^[i,1])+maxX div 2;

Wsp^[i,2]:=round(XYZ^[i,2])+maxY div 2;

end;

SetBkColor(blue); SetColor(white);



LineStyle:=SolidLn; {DottedLn;CenterLn;DashedLn;}

Pattern:=0;

Thickness:=NormWidth; {ThickWidth;}

SetLineStyle(LineStyle,Pattern,Thickness);

DrawPolyg(1,ilo,Wsp); DrawPolyg(ilo+1,ilo*2,Wsp);

DrawPolyg(ilo*2+1,ilo*3,Wsp); DrawPolyg(ilo*3+1,ilo*4,Wsp);

DrawPolyg(ilo*4+1,il1,Wsp); DrawPolyg(il1+1,il2,Wsp);

DrawPolyg(il2+1,il3,Wsp); DrawPolyg(il3+1,il4,Wsp);

Readln; CloseGraph;dispose(XYZ);dispose(WSP);

END.


>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>







Program RzutOrtPerAks; uses crt,printer,Graph,tooll,Funct;

const ilp=16;ilm=513;

Dane:array[1..ilp,1..3] of real=

((0,0,0),

(1,0,0),


(1,2,0),

(0,2,0),


(0,0,0),

(0,0,3),


(1,0,3),

(1,2,3),


(0,2,3),

(0,0,3),


(1,0,0),

(1,0,3),


(1,2,0),

(1,2,3),


(0,2,0),

(0,2,3));

{$I c:\mmw\RotPoly.pas}

VAR Gd, Gm,il,ii,i,j:integer;

Skala,Alx,Aly,Alz,
x0,y0,z0,fi,alfa:real;

XYZ,XYZ1:PXYZReal; Wsp:PWspXY;

Procedure Perspektywa(ilp:integer;x0,y0,z0:real;XYZ:PXYZReal;var XYZ1:PXYZReal);

var x,y,z,x1,y1:real;ii:integer;

begin

for ii:=1 to ilp do



begin

x:=XYZ^[ii,1];

y:=XYZ^[ii,2];

z:=XYZ^[ii,3];

{ x1:=x;y1:=y;}

x1:=-(x-x0)/(z-z0)*z0+x0;

y1:=-(y-y0)/(z-z0)*z0+y0;

XYZ1^[ii,1]:=x1;

XYZ1^[ii,2]:=y1;

XYZ1^[ii,3]:=z;

end;

end;


Procedure Aksonometria(ilp:integer;fi,alfa:real;XYZ:PXYZReal;var XYZ1:PXYZReal);

var x,y,z,x1,y1:real;ii:integer;

begin

for ii:=1 to ilp do



begin

x:=XYZ^[ii,1];

y:=XYZ^[ii,2];

z:=XYZ^[ii,3];

{ x1:=x;y1:=y;}

x1:=x+z*cos(fi)/tan(alfa);

y1:=y-z*sin(fi)/tan(alfa);

XYZ1^[ii,1]:=x1;

XYZ1^[ii,2]:=y1;

XYZ1^[ii,3]:=z;

end;

end;


Begin

Gd := Detect; InitGraph(Gd, Gm, '');

new(XYZ);new(XYZ1);new(WSP);

skala:=100;ii:=0;Alx:=pi/90.0;Aly:=pi/90.0;Alz:=pi/90;

x0:=0.5;y0:=1;z0:=-3;

fi:=30{45}*pi/180;alfa:=45{63}*pi/180;

for i:=1 to ilp do

begin


ii:=ii+1;

XYZ^[ii,1]:=Dane[ii,1]*Skala;

XYZ^[ii,2]:=Dane[ii,2]*Skala;

XYZ^[ii,3]:=Dane[ii,3]*Skala;

end;

il:=ii;


Repeat

Rot(il,1,Alx,0,0,0,XYZ); Rot(il,2,Aly,0,0,0,XYZ); Rot(il,3,Alz,0,0,0,XYZ);

Perspektywa(il,x0,y0,z0,XYZ,XYZ1);

Aksonometria(il,fi,alfa,XYZ,XYZ1);

for i:=1 to il do

begin


Wsp^[i,1]:=round(XYZ1^[i,1])+100;

Wsp^[i,2]:=round(XYZ1^[i,2])+200;

end;

SetBkColor(blue); SetColor(white);



ClearDevice;

DrawPolyg(1,10,Wsp); DrawPolyg(11,12,Wsp);

DrawPolyg(13,14,Wsp); DrawPolyg(15,16,Wsp);
Delay(50);

until Keypressed;

readln; CloseGraph;

dispose(XYZ);dispose(XYZ1);dispose(WSP);



end.
Pobieranie 63.31 Kb.





©absta.pl 2020
wyślij wiadomość

    Strona główna