4. Hilfe bei Robotersimulation

Hilfe bei Robotersimulation

  • ?

    Hallo liebe Community,

    ich muss für mein Studium (Maschinenbau) ein C-Programm erstellen, welches den Bespannvorgang eines Tennisschlägers mit Hilfe eines Roboters simuliert. Hierbei muss die Schlägergröße (Ellipsengröße),die Saitenanzahl in vertikaler und horizontaler Richtung sowie die Saitenfarbe in horizontaler und vertikaler Richtung variabel sein.

    Bis jetzt haben wir die Schlägerkontur (Ellipsengröße) inklusive Griff variabel erstellt.
    Momentan sind wir dabei, die Koordinaten der auf der Ellipse liegenden Anfangs- bzw. Endpunkte der Saiten berechnen zu lassen. Hierbei haben wir aber leider das Problem, dass wir nicht wissen, wie wir die einzelnen Punkte ansprechen können. Wir haben zwar alle nötigen Punkte auf der Ellipse in Abhängigkeit von der Ellipsengröße und der Saitenzahl berechnet, jedoch können wir die einzelnen gegenüberliegenden Punkte ansprechen, um diese mit PaintLinie zu verbinden.

    Kann mir eventuell jemand von euch mit diesem Problem weiterhelfen?
    Vielen Dank schon mal im Voraus.

    PS: Falls ihr noch Fragen haben solltet kann ich gerne versuchen, die Aufgabenstellung und auch das momentan bestehende Programm hochzuladen.

    0
  • ?

    Ich verstehe das Problem nicht: Ihr kennt alle Punkte, könnt aber die API (z.B. PaintLinie(sic!)) nicht benutzen?

    0
  • ?

    Die Punkte werden in einer For-Schleife mit einer Laufvariablen t berechnet. Diese zählt den Abstand zwischen den einzelnen Saiten zum X-Wert. Somit haben wir die einzelnen Punkte im Uhrzeigersinn berechnet. Wir brauchen jedoch einen bestimmten und dazu den gespiegelten Punkt an der horizontalen/vertikalen um die Saite zeichnen zu können.

    0
  • ?

    /////X positiv /////Y positiv /////
    for(t=0;t<=(anzahl_saiten_vert-1)/2;t++)
    {
    x_wert=(bandlaenge/2)/((anzahl_saiten_vert+1)/2);
    naben[t].x=x_wertt;
    naben[t].y=Ellipsenpunkte(bandbreite, bandlaenge, anzahl_saiten_vert, anzahl_saiten_hori, x_wert    t);
    printf("%lf\t",naben[t].x);
    printf("%lf\n",naben[t].y);
    }

    double Ellipsenpunkte(double bandbreite, double bandlaenge, double anzahl_saiten_vert, double anzahl_saiten_hori, double x_wert)
    {
    double xelli, yelli, a, b;

    a=bandlaenge/2;
    b=bandbreite/2;

    yelli=sqrt( (1- ( (x_wert*x_wert) / (a*a) ) )(bb) );

    return(yelli);
    }

    0
  • B

    Ich würde deinen Schläger an der Y Achse ausrichten und danach die Ellipsenpunkte berechnen.

    Nun kann man die Liste nach Y sortieren. Haben zwei Punkte den gleichen Y Wert, so sortiert man nach X. Die Liste dürfte nun folgende Form haben (P0, PG0, P1, PG1,...) was soviel bedeutet das für einen Punkt Pi in der Liste der folgende Punkt dem gegenüberliegende Punkt auf dem Schläger entspricht.

    Danach könntest du die Liste nach X sortieren und das gleiche Spiel machen.

    Die Ergebnisse könntest du in beispielsweise in folgender Datenstruktur abspeichern.

    typedef struct
{
  double x;
  double y;
  double z;
  int ID; // Eindeutige ID zur Identifikation des Punktes
  int NeighY; // ID des gegenüberliegenden Punktes in Y Richtung. Ist -1 wenn kein gegenübeliegender Punkt vorhanden ist.
  int NeighX; // ID des gegenüberliegenden Punktes in X Richtung. Ist -1 wenn kein gegenübeliegender Punkt vorhanden ist.
} tThugPoint; // :->

    PS:
    Muss es C sein? C++ hat mittels STL viele schöne Containerklassen!

    0
  • ?

    Schon mal Danke für deine Antwort.
    Ja es muss leider C sein 😡 😡 😡

    Okay der Sinn dahinter leuchtet mir ein.

    Aber wie kann ich den Schläger an der Y Achse ausrichten? Außerdem ist der Mittelpunkt der Ellipse immer in deren Mitte und mit dieser Berechnung werden dann auch die Punkte berechnet.

    0
  • B

    Nicht irritieren lassen.

    Ich glaube anhand deiner Berechnung erkennen zu können, dass der Schläger schon an der Y Achse ausgerichtet ist.

    Zeichne doch die Schlägerpunkte als auch die Y Achse mit Hilfe von wxWidgets, WinApi oder was auch immer. Dann siehst du es direkt.

    0
  • ?

    Hallo Bitte ein Bit,

    Danke für deine Hilfe! Ich versuche mich mal dahingehend einzulesen, aber ich bin mir nicht sicher, ob WinApi und wxWidgets ein Teil der C-Programmsprache ist und wir unser Programm nur in C programmieren sollen.

    Gibt es eine Möglichkeit, dir die Aufgabenstellung zukommen zu lassen und evtl. unser bestehendes Programm?
    Ich tue mir bereits schwer dies vernünftig zu beschreiben, wo das Problem liegt.

    Das wäre eine super Hilfe! 👍 👍 😃 🙂

    0
  • ?

    winapi ist teil des windows-betriebssystems, aber in c geschrieben, der vorschlag war aber glaub ich auch mehr für dich zur kontrolle. winapi braucht eine relativ lange einarbeitungszeit.

    hier hast du ein programmgerüst. für linien musst du erstmalig MoveToEx(hdc, x,y,0) und dann LineTo(hdc,x,y) für jeden weiteren Punkt (werden dann durchverbunden) an der markierten stelle aufrufen.

    #include <Windows.h>

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //Prototyp der Callback-Funktion

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
	static TCHAR szAppName[] = TEXT("Aufgäbe 1"); //Name der Anwendung
	HWND hwnd; //Handle aufs Fenster
	MSG msg; //MSG Struktur
	WNDCLASS wndclass; //Window Class Struktur, enthält die Window Class Attribute, die mit RegisterClass() registriert werden. Wurde durch WNDCLASSEX ersetzt und ist daher eigentlich veraltet.

	wndclass.style = CS_HREDRAW | CS_VREDRAW; //Window Class Styles
	wndclass.lpfnWndProc = WndProc; //Pointer auf die "Window-Prock"
	wndclass.cbClsExtra = 0; //Anzahl der Extra-Bytes, die auf die Window Class folgend alloziiert werden sollen.
	wndclass.cbWndExtra = 0; //Anzahl der Extra-Bytes, die auf die Window Instance folgend alloziiert werden sollen.
	wndclass.hInstance = hInstance; //Handle auf die Instanz, die die Window-Prozedur für diese Window Class enthält.
	wndclass.hIcon = LoadIcon(0, IDI_APPLICATION); //Handle auf das Class Icon, das in der Titelleiste und in der Taskleiste angezeigt werden soll
	wndclass.hCursor = LoadCursor(0, IDC_HAND); //Handle auf den Cursor, aufgrund persönlicher Vorlieben des Programmierers ein Hand-Symbol 
	wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); //Handle auf den Background Brush. Sorgt in diesem Fall für einen weißen Hintergrund.
	wndclass.lpszMenuName = 0; //Festlegung eines Menüs. Hier kein Menü, daher 0
	wndclass.lpszClassName = szAppName; //Name der Fensterklasse

	if (!RegisterClass(&wndclass)) //Registriert die Window Class für nachfolgende Aufrufe von CreateWindow. Wurde durch RegisterClassEx ersetzt und ist daher eigentlich veraltet.
	{
		MessageBox(0, TEXT("Fehler!"), szAppName, MB_ICONERROR); //Gibt eine Nachricht aus, falls der Aufruf von RegisterClass() fehlschlagen sollte
		return 0;
	}

	hwnd = CreateWindow(szAppName, TEXT("Aufgabe 1"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hInstance, 0); //Erstellt das Fenster. Wurde durch CreateWindowEx ersetzt und ist daher eigentlich veraltet. Sendet WM_CREATE an die Window-Prock

	ShowWindow(hwnd, iCmdShow); //Setzt den spezifizierten Anzeigestatus des Fensters
	UpdateWindow(hwnd); //Aktualisiert die "client area" des Fensters, indem es eine WM_PAINT-Nachricht sendet.

	while (GetMessage(&msg, 0, 0, 0)) //Ruft die nächste Nachricht ab
	{
		TranslateMessage(&msg); //Nachrichten, die von der Tastatur erzeugt wurden, umwandeln
		DispatchMessage(&msg); //Nachrichten an die Window-Prock senden bzw. die Window-Prock aufrufen
	}

	return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HDC hdc; //Handle für einen Gerätekontext ("device context")
	PAINTSTRUCT ps; //Struktur für Zeichenoperationen
	RECT rect; //Struktur, die einen rechteckigen Bereich beschreibt ("rectangle")

	switch (message) 
	{
	case WM_CREATE: //Wurde von CreateWindow() geschickt. Hier finden also weitere Initialisierungen statt.
		return 0;
	case WM_PAINT:  //Informiert ein Fenster darüber, dass der Inhalt teilweise oder komplett ungültig ist.
		hdc = BeginPaint(hwnd, &ps); //Bereitet des Fenster auf die Zeichenoperationen vor und füllt die PAINTSTRUCT mit den nötigen Informationen

		GetClientRect(hwnd, &rect); //Kopiert die Dimensionen des Fensterinhalts in die RECT-Struktur. 

//Hier Zeichenoperationen und Berechnungen einfügen

		EndPaint(hwnd, &ps); //Beendet die Zeichenoperation.
		return 0;
	case WM_DESTROY: //Wird von Windows als Reaktion auf einen Klick das Schließen-Feld ("X"), die Tastenkombination Alt + F4 usw erzeugt. 
		PostQuitMessage(0); //Fügt WM_QUIT in die Nachrichten-Warteschlange ein. Hiermit wird die Endlosschleife in der WinMain beendet.
		return 0;
	}

	return DefWindowProc(hwnd, message, wParam, lParam); //Ruft die Default-Window-Prock auf, damit sich diese um die Nachrichten kümmern kann, die hier nicht bearbeitet werden.
}
    0
  • ?

    MB-Scara schrieb:

    Gibt es eine Möglichkeit, dir die Aufgabenstellung zukommen zu lassen und evtl. unser bestehendes Programm?

    faule Sau!

    0
  • ?

    Hanswurst123 schrieb:

    MB-Scara schrieb:

    Gibt es eine Möglichkeit, dir die Aufgabenstellung zukommen zu lassen und evtl. unser bestehendes Programm?

    faule Sau!

    Ähm: Nein! so kommunizieren wir nicht in diesem Forum.

    0
  • ?

    @Hanswurst123 ich habe nirgends geschrieben "Mach mal unser Projekt". Lediglich wollte ich die Aufgabenstellung und das Programm offen legen, sodass andere nachvollziehen können was genau mein Problem ist und bei welchem Ansatz ich gerade stehe.

    0
  • ?

    Das ist unsere bestehendes Hauptprogramm.

    #include "header8.h"

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,PSTR szCmdLine, int iCmdShow)
	{
	static TCHAR szAppName[] = TEXT ("HelloWin");
	HWND		hwnd, hwnd2;
	MSG		msg;
	WNDCLASS	wndclass;

	wndclass.style			= CS_HREDRAW | CS_VREDRAW;
	wndclass.lpfnWndProc		= WndProc;
	wndclass.cbClsExtra		= 0;
	wndclass.cbWndExtra		= 0;
	wndclass.hInstance		= hInstance;
	wndclass.hIcon			= LoadIcon (NULL, IDI_APPLICATION);
	wndclass.hCursor		= LoadCursor (NULL,IDC_ARROW);
	wndclass.hbrBackground		= (HBRUSH) GetStockObject (WHITE_BRUSH);
	wndclass.lpszMenuName		= NULL;
	wndclass.lpszClassName		= szAppName;

	if (!RegisterClass (&wndclass))
		{
		MessageBox(NULL,TEXT ("Programm setzt WIN NT voraus"), szAppName, MB_ICONERROR);
		return 0;
		}

	hwnd = CreateWindow (

			szAppName,
			TEXT ("Unser erstes Fenster für mb3b"),
			WS_OVERLAPPEDWINDOW,
			50,
			50,
			600,
			400,
			NULL,
			NULL,
			hInstance,
			NULL);

	anzp_schlaeger= punkte_r3 (schlaeger, "schlaeger.txt");

	stift1=CreatePen(PS_SOLID,1,RGB(0,0,0));//durchgezogen, dicke 1, weiß
	stift2=CreatePen(PS_SOLID,schlaeger[1][0],RGB(schlaeger[2][0],schlaeger[2][1],schlaeger[2][2]));
	stift3=CreatePen(PS_SOLID,1,RGB(255,0,0));//druchgezogen, dicke 1, rot
	stift4=CreatePen(PS_DOT,1,RGB(0,0,255));//Eigentlich bewegungslinie in blau gestrichelt "dot"

	hintergrund1=CreateSolidBrush(RGB(255,255,255));
	hintergrund2=CreateSolidBrush(RGB(0,0,0));//Flaeche schwarz
	hintergrund3=CreateSolidBrush(RGB(0,255,0));// Flaeche

	ShowWindow (hwnd, iCmdShow);

	while (GetMessage (&msg, NULL, 0,0))
		{
			TranslateMessage (&msg);
			DispatchMessage (&msg);
		}
		return msg.wParam;
	}

	LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
		switch (message)
		{
			case 	WM_PAINT:
			hdc = BeginPaint (hwnd, &ps);
			GetClientRect (hwnd, &rect);
			//DrawText (hdc, TEXT("Hallo MBB3b! Das ist mein erstes Fenster im Maerz 2016"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_TOP);
			unterprog1 (hwnd, hdc, rect);

			return 0;

			case 	WM_DESTROY:
					PostQuitMessage (0);
					return 0;

			case WM_LBUTTONDOWN: // linke Maustaste

				xe = (double)LOWORD(lParam); //Neue Pos aus Mauskoordinaten
				ye = (double)HIWORD(lParam);
				movexy(hwnd);

				return 0;
		}
	return DefWindowProc (hwnd, message, wParam, lParam);
}

				//case 'G':	naben[3].greifer=1;break;// Nabe 3 greifen
				//case 'L':	naben[3].greifer=0;break;// loslassen

void movexy(HWND hwnd)
{
	char wtext[80];
	UpdateWindow (hwnd);
//sprintf(wtext, "Aktuelle Pos.: x = %3.2lf, y = %3.2lf",xe, ye);
			//SetWindowText(hwnd, wtext); //Titelleiste akt.

			//SelectObject(hdc,stift1);

			//MoveToEx(hdc,xa,ya,NULL);
			//LineTo(hdc,xe,ye);
			//xa=xe;
			//ya=ye;
			bewegen(hwnd);

}//ausgelagertes Unterprogramm zum Test der Graphikfunktionen

void unterprog1 (HWND hwnd, HDC hdc, RECT rect)
{
int i;

t_step=10;
t_max=500;
anz_p1=7;
anz_p2=8;

anzahl_saiten_vert=schlaeger[3][0]; ////////////////////////MUSS vor den anz_nab deklariert werden////////////////////////
//anzahl_saiten_hori=schlaeger[4][0]; ////////////////////////MUSS vor den anz_nab deklariert werden////////////////////////
anz_nab=anzahl_saiten_vert*4;
//anz_nab=anzahl_saiten_vert*4;
v_band=0; // Pixel/sec

anzp_koerpern=0;
koerper_greifer=0; // nicht gegriffen

l=-1;
linie_ein=0; // sprühkopf aus

SelectObject(hdc,stift1);

anzp_nabform= punkte_r (nab_form, "form_nab.txt"); //siehe auch Kapitel 10

anzp_koerper= punkte_r (koerper, "koerper8.txt"); //siehe auch Kapitel 10

//////////////////////////////////Form der Roboterarme/////////////////////////////////////////////
arm1[0][0]=-20;
arm1[0][1]=-20;
arm1[1][0]=-20;
arm1[1][1]=130;
arm1[2][0]=20;
arm1[2][1]=130;
arm1[3][0]=20;
arm1[3][1]=-20;
arm1[4][0]=arm1[0][0];
arm1[4][1]=arm1[0][1];
arm1[5][0]=0;
arm1[5][1]=0;
arm1[6][0]=0;
arm1[6][1]=110;

arm2[0][0]=-20;
arm2[0][1]=-20;
arm2[1][0]=-20;
arm2[1][1]=130;
arm2[2][0]=0;
arm2[2][1]=150;
arm2[3][0]=20;
arm2[3][1]=130;
arm2[4][0]=20;
arm2[4][1]=-20;
arm2[5][0]=arm2[0][0];
arm2[5][1]=arm2[0][1];
arm2[6][0]=0;
arm2[6][1]=0;
arm2[7][0]=0;
arm2[7][1]=110;
///////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////Koordianten des Schlägers///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////Ellipse

bandbreite=schlaeger[0][0]; /////////Breite der Ellipse
bandlaenge=schlaeger[0][1]; /////////Länge der Ellipse
band_pos_x=300; /////////Schlägermittelpunkt Mitte von der Ellipse (x=0)
band_pos_y=150; /////////Schlägermittelpunkt Mitte von der Ellipse (x=0)
band[0][0]=band_pos_x-bandlaenge/2;
band[0][1]=band_pos_y-bandbreite/2;
band[1][0]=band_pos_x+bandlaenge/2;
band[1][1]=band_pos_y+bandbreite/2;/////////////////////////////////////////////////////////////////Ellipse

griffbreite=20;/////////////////////////////////////////////////////////////////////////////////////Griff
grifflaenge=150;
griff[0][0]=band_pos_x+bandlaenge/2;
griff[0][1]=band_pos_y-griffbreite/2;
griff[1][0]=band_pos_x+bandlaenge+grifflaenge;
griff[1][1]=band_pos_y-griffbreite/2;
griff[2][0]=griff[1][0];
griff[2][1]=band_pos_y+griffbreite/2;
griff[3][0]=griff[0][0];
griff[3][1]=band_pos_y+griffbreite/2;//////////////////////////////////////////////////////////////Griff

///////////////////////////////////////////////////////Nabenpunkte die Roboterarm anfährt = Punkte auf der Ellipse
int t;
int k=-1, j=-1, l=-1;

/////X positiv /////Y positiv /////
for(t=0;t<=(anzahl_saiten_vert-1)/2;t++)
	{
		x_wert=(bandlaenge/2)/((anzahl_saiten_vert+1)/2);
		naben[t].x=x_wert*t;
		naben[t].y=Ellipsenpunkte(bandbreite, bandlaenge, anzahl_saiten_vert, anzahl_saiten_hori, x_wert*t);
		printf("%lf\t",naben[t].x);
		printf("%lf\n",naben[t].y);
	}
/////X negativ /////Y positiv /////
for(t=(anzahl_saiten_vert+1)/2;t<=anzahl_saiten_vert;t++)
	{
		x_wert=(bandlaenge/2)/((anzahl_saiten_vert+1)/2);
		k++;
		naben[t].x=(-1)*x_wert*k;
		naben[t].y=Ellipsenpunkte(bandbreite, bandlaenge, anzahl_saiten_vert, anzahl_saiten_hori, x_wert*(-1)*k);
		printf("xxx%lf\t",naben[t].x);
		printf("%lf\n",naben[t].y);
	}
/////X negativ /////Y negativ /////
for(t=anzahl_saiten_vert+1;t<=((anzahl_saiten_vert*2)-((anzahl_saiten_vert-1)/2));t++)
	{
		x_wert=(bandlaenge/2)/((anzahl_saiten_vert+1)/2);
		l++;
		naben[t].x=(-1)*x_wert*l;
		naben[t].y=(-1)*(Ellipsenpunkte(bandbreite, bandlaenge, anzahl_saiten_vert, anzahl_saiten_hori, x_wert*(-1)*l));
		printf("zzz%lf\t",naben[t].x);
		printf("%lf\n",naben[t].y);
	}
/////X positiv /////Y negativ /////
for(t=(((anzahl_saiten_vert*2)+1)-((anzahl_saiten_vert-1)/2));t<=(anzahl_saiten_vert*2)+1;t++)
	{
		x_wert=bandlaenge/(anzahl_saiten_vert+1);
		j++;
		naben[t].x=x_wert*j;
		naben[t].y=(-1)*(Ellipsenpunkte(bandbreite, bandlaenge, anzahl_saiten_vert, anzahl_saiten_hori, x_wert*j));
		printf("yyy%lf\t",naben[t].x);
		printf("%lf\n",naben[t].y);
	}////////

l1=arm1[anz_p1-1][1]-arm1[anz_p1-2][1];///////Abstand der Punkte des ersten Roboterarmes = Länge des Roboterarmes
l2=arm2[anz_p2-1][1]-arm2[anz_p2-2][1];///////Abstand der Punkte des ersten Roboterarmes = Länge des Roboterarmes

verschiebung[0]=band_pos_x; ////////////////////////////////////////Position des Roboter Hauptarmes
verschiebung[1]=band_pos_y+(bandbreite/2)+50; //////////////////////Position des Roboter Hauptarmes

linie_ein=1;// sprühkopf ein=1 sprühkopf aus=0
xa=verschiebung[0]; // Startpunkt festlegen
ya=verschiebung[1];

	/*
	xe=xa+100; //Anfangspunkt auf den der Roboter als Erstes fährt
	ye=ya; //Anfangspunkt auf den der Roboter als Erstes fährt
	bewegen(hwnd);
	*/
	t_max=500; // für konstante v sollte t_max proportional zur Strecke sein

for (i=0;i<anz_nab;i++)
	{
		xe=band_pos_x+naben[i].x;
		ye=band_pos_y-naben[i].y;
		bewegen(hwnd);
	}// for i...

xe=450; //Endpunkt auf den der Roboter am Ende des Programmes fährt
ye=250; //Endpunkt auf den der Roboter am Ende des Programmes fährt
bewegen(hwnd);

linie_ein=0;// sprühkopf ein=1 sprühkopf aus=0
}// void unterprog1

//////////////////////////////////////////////////
//////////////////////////////////////////////////
//////////////Zeichnet Roboterarm/////////////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
void PaintArm(double arm[][2], int anz_p)
{
double r=5; // Radius der Roboterachsen
int i;
POINT pt[100];
for (i=0;i<anz_p-2;i++)
	{
		pt[i].x=(int)arm[i][0];
		pt[i].y=(int)arm[i][1];
		}
		//Polygon(hdc,pt,anz_p-2);
		Polyline(hdc,pt,anz_p-2);
Ellipse(hdc,arm[anz_p-2][0]-r,arm[anz_p-2][1]-r,arm[anz_p-2][0]+r,arm[anz_p-2][1]+r);
Ellipse(hdc,arm[anz_p-1][0]-r,arm[anz_p-1][1]-r,arm[anz_p-1][0]+r,arm[anz_p-1][1]+r);
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
//////////////Zeichnet den Schläger///////////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
void PaintSchlaeger(double polyg1[][2], int anz_p1, double polyg2[][2], int anz_p2)
{
int i;
POINT pt[100];
for (i=0;i<anz_p2;i++)//////////////////////////////////////////////////////Griff zeichnen
	{
		pt[i].x=(int)polyg2[i][0];
		pt[i].y=(int)polyg2[i][1];
		}
		SelectObject(hdc,hintergrund2);
		Polygon(hdc,pt,anz_p2);
		SelectObject(hdc,hintergrund1);

for (i=0;i<anz_p1;i++) /////////////////////////////////////////////////////Ellipse zeichnen
	{
		pt[i].x=(int)polyg1[i][0];
		pt[i].y=(int)polyg1[i][1];
		}
		SelectObject(hdc,stift2);
		Ellipse(hdc,band[0][0],band[0][1],band[1][0],band[1][1]);
		SelectObject(hdc,stift1);
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
///////Zeichnet den Griff des Schlägers///////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
void PaintPolyg(double polyg[][2], int anz_p)
{
int i;
POINT pt[100];
for (i=0;i<anz_p;i++)
	{
		pt[i].x=(int)polyg[i][0];
		pt[i].y=(int)polyg[i][1];
		}
		Polygon(hdc,pt,anz_p);
		//Polyline(hdc,pt,anz_p-2);
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
////////////////Zeichnet Naben ///////////////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
void PaintNaben(int anz_p)
{
double r=10; // Radius der Naben
double rk=5; // Radius für kleine Naben // typ 2
int i;
int j;
double formn[100][2];
double winkel=0;
double drehpunkt[2];
drehpunkt[0]=0;
drehpunkt[1]=0;
	for(i=0;i<anz_p;i++)
		{
		if (naben[i].typ==1)	Ellipse(hdc,naben[i].x-r,naben[i].y-r,naben[i].x+r,naben[i].y+r);
		if (naben[i].typ==2)	Ellipse(hdc,naben[i].x-rk,naben[i].y-rk,naben[i].x+rk,naben[i].y+rk);// kleine Naben

		if (naben[i].typ==3)
			{
				shiftpunkt[0]=naben[i].x;
				shiftpunkt[1]=naben[i].y;

				for (j=0;j<anzp_nabform;j++)
					{
						TrafoPoint (nab_form[j], formn[j], naben[i].winkel, drehpunkt, shiftpunkt);
					} // for j..
				PaintPolyg(formn, anzp_nabform);
			}
		}
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
////////Weg des Roboters mit Linie zeigen/////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
void PaintLinie(void)
{
int i;
	SelectObject(hdc,stift4);
	for (i=0;i<=l;i++)
		{
			MoveToEx(hdc,linie[i][0][0],linie[i][0][1],NULL) ;// linie i anfangshiftpunkt
			LineTo(hdc,linie[i][1][0],linie[i][1][1]);
		}	// for i..
	SelectObject(hdc,stift1);
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
//////////////Ellipsenpunkte berechnen////////////
//////////////////////////////////////////////////
//////////////////////////////////////////////////
double Ellipsenpunkte(double bandbreite, double bandlaenge, double anzahl_saiten_vert, double anzahl_saiten_hori, double x_wert)
{
double xelli, yelli, a, b;
	a=bandlaenge/2;
	b=bandbreite/2;

	yelli=sqrt(  (1- ( (x_wert*x_wert) / (a*a) ) )*(b*b)  );
	//xelli=sqrt(  (1- ( (y_wert*t*t*y_wert) / (b*b) ) )*(a*a)  );

	return(yelli);
}
    0
Anmelden zum Antworten