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.



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



  • 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.



  • /////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);
    }



  • 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!



  • 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.



  • 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.



  • 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! 👍 👍 😃 🙂



  • 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.
    }
    


  • MB-Scara schrieb:

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

    faule Sau!



  • 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.



  • @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.



  • 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);
    }
    

Log in to reply