Winapi ошибка "недопустимый параметр был передан функции"

#include "stdafx.h"
#include "draw2.h"
#include <vector>
#include <cstdio>
#include <fstream>
#include <iostream>
#include <cstring>
#include <sstream>
#include <string>
#include <iomanip>
 
 
#define MAX_LOADSTRING 100
#define TMR_1 1
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
INT value;
 
//********** - mozna zmieniac, podstawiac inna wartosc, jesli rozpatrywac inny przypadek
 
// DEKLAROWANE DANE
struct przesun {
    int poziomo;
    int pionowo;
};
 
std::vector <double> roll; 
std::vector <double> pitch;
std::vector <double> yaw;
std::vector<double> vec; // vec - ten wektor ktory bedziemy obserwowac, tylko zakres katowy zmienia sie z [-180;180] na [0;360]
std::vector <double> wybr; // ten sam wybrany wektor s zakresem katowym [-180;180]
std::vector<przesun> kat; // kat - wektor struktur, pokazujacy, o ile pikseli trzeba przesunac kat obrotu; do rysowania katu 
 
int j = 0; // dlugosc powyzszyvh wektorow - 1
int i = 0; // dla rysowania katu
 
// FUNKCJE
int Wczytaj_roll_pitch_yaw(); // f-cja wczytuje dane katowe z pliku
void licz_obroty(int j); // f-cja liczy obroty prawostronne i lewostronne 
void przetworz_wektor_na_wygodny(int j, std::vector <double> &vec); // funkcja zmienia zakres kata, ktory obserwujemy z [-180;180] na [0;360]
void czy_900_stopni(double &obr_p, double &obr_l, int y, double &dsp, double &dsl, std::vector <double> vec); //f-cja sprawdza, czy cialo sie obrocilo o 900 stopni  (2.5 obrotu)
void przesun_kat_dla_grafu(int j, std::vector <double> vec); // f-cja tworzaca wektor struktur kat, ktory zawiera dane, o ile pikseli trzeba przesunac kat
 
 
// buttons
HWND hwndButton;
 
// sent data
int col = 0;
std::vector<Point> data;
RECT drawArea1 = { 0, 0, 550, 400 }; // obszar, gdzie robimy repaint
RECT drawArea2 = { 50, 400, 650, 422};
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    Buttons(HWND, UINT, WPARAM, LPARAM);
 
 
int Wczytaj_roll_pitch_yaw()
{
    std::ifstream plik;
    plik.open("hPlik.log", std::ios::binary); // mozna i nie binary
 
    if (!plik)
    {
        MessageBox(NULL, _T("Nie można otworzyć pliku."), _T("A to pech!"), MB_ICONEXCLAMATION);
        PostQuitMessage(0); // Zakończ program
    }
    int i = 0;
    std::string line;
    while (std::getline(plik, line))
    {
        if (i < 112)
        {
            std::stringstream iss(line);
            i++;
        }
        else
        {
        //  std::cout << line << std::endl;
            float x, y, z;
            std::stringstream iss(line);
 
            iss >> x >> y >> z;
 
            roll.push_back(x);
            pitch.push_back(y);
            yaw.push_back(z);
 
        //  std::cout << "\tRoll =" << std::fixed << std::setprecision(3) << roll[j] << std::endl;
        //  std::cout << "\tPitch =" << pitch[j] << std::endl;
        //  std::cout << "\tYaw =" << yaw[j] << std::endl;
            j++;
        }
    }
    j--;
    plik.close();
    return j; // f-cja zwraca dlugosc wektorow (-a) - 1 
}
 
 
void przetworz_wektor_na_wygodny (int j, std::vector <double> &vec) // funkcja zmienia zakres kata, ktory obserwujemy z [-180;180] na [0;360]
{
    vec;// vec - kopia wektora, ktory bedziemy obserwowac (tu wybralismy yaw)
    double z = vec[0]; // od tej wartosci bedziemy liczyc obroty
 
    if (vec[0] > 0) // najwygodniej liczyc obroty od 0, dlatego przesuwamy wszystkie liczby o wartosc pocz. vec[0], jest to nasz punkt poczatkowy
    {
        for (int i = 0; i < j; i++)
        {vec[i] = vec[i] - z;}
    }
 
    if (vec[0] < 0) // analogicznie jak wyzej
    {
        for (int i = 0; i < j; i++) 
        {vec[i] = vec[i] - z;}
    }
 
    for (int i = 0; i < j; i++) // ujemne wartosci liczb zamieniamy na dodatnie dodajac 360 (z tego wynika ze caly obro rowny jest 360 stopni)
    {                           // tak wygodniej liczyc obroty
        if (vec[i] < 0)
        {vec[i] = 360 + vec[i];}
    }
}
 
 
void czy_900_stopni(double &obr_p, double &obr_l, int y, double &dsp, double &dsl, std::vector <double> vec)  //f-cja sprawdza, czy cialo sie obrocilo o 900 stopni  (2.5 obrotu)
{
    if (obr_p == dsp) // jezeli jest zrobiony caly obrot (bez polowek), np. 5
    {
        std::cout << "ObrotP :" << obr_p << "; wartosc: 900 stopni" << std::endl;
        dsp = dsp + 2.5; // poszerzamy zakres obrotow (jesli jest to nadal prawostronny obrot)
    }
        
 
    if (vec[y - 1] < 180 & vec[y] >= 180) // jezeli zrobiono pol obrotu
    {
        obr_p = obr_p + 0.5;
        if (vec[y - 1] < 180 & vec[y] >= 180 & obr_p == dsp) // jezeli minelo kolejne 2.5 obrotu
        {
            std::cout << "ObrotP :" << obr_p << "; wartosc: 900 stopni" << std::endl;
            //system("pause");
            dsp = dsp + 2.5; // poszerzamy zakres obrotow (jesli jest to nadal prawostronny obrot)
        }
    }
        
    if (obr_l == dsl) // jezeli jest zrobiony caly obrot (bez polowek), np. 5
    {
        //std::cout << "ObrotL: " << obr_l << "; wartosc: 900 stopni" << std::endl;
        dsl = dsl + 2.5; // poszerzamy zakres obrotow (jesli jest to nadal lewostronny obrot)
    }
 
    if (vec[y - 1] > 180 & vec[y] <= 180) // jezeli zrobiono pol obrotu
    {
        obr_l = obr_l + 0.5;
        if (vec[y - 1] > 180 & vec[y] <= 180 & obr_l == dsl) // jezeli minelo kolejne 2.5 obrotu
        {
            std::cout << "ObrotL: " << obr_l << "; wartosc: 900 stopni" << std::endl;
            //system("pause");
            dsl = dsl + 2.5; // poszerzamy zakres obrotow (jesli jest to nadal lewostronny obrot)
        }
    }
}
 
 
void licz_obroty(int j) // f - cja liczy obroty prawostronne i lewostronne
{
    vec = yaw; //*********** vec - kopia wektora, ktory wybralismy (tu wybralismy yaw)
    vec.assign(yaw.begin(), yaw.end()); //***********
    przetworz_wektor_na_wygodny(j, vec); // przetwarzamy vec tak, zeby kat obrotu byl 360 stopni
 
    wybr = yaw; //*********** wybr - wybrany wektor, kopia wektora, ktory wybralismy (tu wybralismy yaw), ale z zakresem obrotu kata [-180;180]
    wybr.assign(yaw.begin(), yaw.end()); //***********
 
 
    double obr_p = 0; // prawostronny obrot
    double obr_l = 0; // lewostronny obrot
    int y = 0; // kiedy y == j , funkcja przestanie liczyc obroty
    int wybor = 1; // nim przelaczamy switchy
    double dsp = 2.5; // dsp - 900 stopni, obrot 2.5 dla prawostronnego obrotu
    double dsl = 2.5; // dsp - 900 stopni, obrot 2.5 dla lewostronnego obrotu
 
    while (y != j) // zakoncz petle jezeli y == j
    {
        switch (wybor)
        {
            case 1:
            {
                if (vec[y + 1] > vec[y] & (wybr[y] - wybr[0]) <= 0) // jezeli wartosci wybr[y] sa ujemne, ale wartosc sie zwieksza
                {
                    while (vec[y + 1] > vec[y] & (wybr[y] - wybr[0]) <= 0) // "wyrownuje" wartosc wybr[y] do wybr[0], zeby od tad zaczac liczyc obroty
                    {
                        y++;
                        if (y == j) // sprawdza, czy zakonczyc dzialanie petli while, to sprawdzenie jest potrzebne po kazdym y++;
                            break;
                        if (wybr[y] == wybr[y + 1]) // na wypadek, jesli z kolei beda te same wartosci kata (w outputRotateA), zeby nie bylo nieskonczonej petli
                            y++;
                    }
                    {if (y == j)
                        break; }
                    // obowiazkowe sprawdzenia
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++; } 
                    // obowiazkowe sprawdzenia
                }
 
                while (vec[y + 1] > vec[y]) // liczenie prawostronnego obrotu
                {
                    obr_l = 0; // wtedy zeruje sie ilosc lewostronnego obrotu
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++; }
                    // obowiazkowe sprawdzenia
                    czy_900_stopni(obr_p, obr_l, y, dsp, dsl, vec); // czy zrobiono 2.5 obrotu
                }
 
                if (wybr[y] < wybr[0] & wybr[y + 1] >= wybr[0]) // jezeli zrobiono caly obrot
                {
                    obr_p = obr_p + 0.5;
                    std::cout << "Obrot P: " << obr_p << std::endl;
                    czy_900_stopni(obr_p, obr_l, y, dsp, dsl, vec); 
 
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++; }
                    // obowiazkowe sprawdzenia
 
                    wybor = 1; // myslimy ze dalej bedzie prawostronny obrot
                    break;
                }
                else
                {
                    wybor = 2; // jezeli nie bedzie to prawostronny obrot, przychodzimy do liczenia lewostronnego obr.
                    break;
                }
            }
 
            case 2:
            {
                if (vec[y + 1] < vec[y] & (wybr[y] - wybr[0]) >= 0)  // jezeli wartosci wybr[y] sa dodatnie, ale wartosc maleje
                {
                    while (vec[y + 1] < vec[y] & (wybr[y] - wybr[0]) >= 0) // "wyrownuje" wartosc wybr[y] do wybr[0], zeby od tad zaczac liczyc obroty
                    {
                        y++;
                        {if (y == j)
                            break;
                        if (wybr[y] == wybr[y + 1])
                            y++; }
                        // obowiazkowe sprawdzenia
                    }
                    {if (y == j)
                        break; }
                    // obowiazkowe sprawdzenia
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++; }
                    // obowiazkowe sprawdzenia
                }
 
                while (vec[y + 1] < vec[y]) // liczenie lewostronnego obrotu
                {
                    obr_p = 0;
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++; }
                    // obowiazkowe sprawdzenia
                    czy_900_stopni(obr_p, obr_l, y, dsp, dsl, vec);
                }
 
 
                if (wybr[y] > wybr[0] & wybr[y + 1] <= wybr[0]) // jezeli zrobiono caly obrot
                {
                    obr_l = obr_l + 0.5;
                    std::cout << "Obrot L: " << obr_l << std::endl;
                    czy_900_stopni(obr_p, obr_l, y, dsp, dsl, vec);
                    
                    y++;
                    {if (y == j)
                        break;
                    if (wybr[y] == wybr[y + 1])
                        y++;}
                    // obowiazkowe sprawdzenia
 
                    wybor = 2;
                    break;
                }
                else
                {
                    wybor = 1;
                    break;
                }
            }
        }
    }
//  przesun_kat_dla_grafu(j, vec);
}
 
void przesun_kat_dla_grafu(int j, std::vector <double> vec)
{
    przesun k;
    int poz;
    int pion;
 
    for (int i = 0; i < j; i++)
    {
        kat.push_back(k);
 
        if (vec[i] > 0 & vec[i] <= 90)
        {
            if (vec[i] > 0 & vec[i - 1] < 360 & vec[i-1]>300)
            {
                poz = vec[i - 1] + vec[i];
                pion = poz;
                kat.at(i).poziomo = poz;
                kat.at(i).pionowo = pion;
            }
            else
            {
                poz = vec[i] - vec[i - 1];
                pion = poz;
                kat.at(i).poziomo = poz;
                kat.at(i).pionowo = pion;
            }
        }
 
        if (vec[i] > 90 & vec[i] <= 180)
        {
            poz = (-1)*(vec[i] - vec[i-1]);
            pion = (-1)*poz;
            kat.at(i).poziomo = poz;
            kat.at(i).pionowo = pion;
        }
 
        if (vec[i] > 180 & vec[i] <= 270)
        {
            /*if (yaw[i] > (-180) & yaw[i - 1] < 180 & yaw[i - 1]>0)
            {
                poz = (180 - yaw[i - 1]) + (180 + yaw[i]);
                if (poz > 0)
                    poz = poz * (-1);
                pion = poz;
                kat.at(i).poziomo = poz;
                kat.at(i).pionowo = pion;
            }
            else*/
            {
                poz = (yaw[i] - yaw[i-1])*(-1);
                pion = poz;
                kat.at(i).poziomo = poz;
                kat.at(i).pionowo = pion;
            }
        }
 
        if (vec[i] > 270 & yaw[i] <= 360)
        {
            poz = yaw[i] - yaw[i - 1];
            pion = (-1)*poz;
            kat.at(i).poziomo = poz;
            kat.at(i).pionowo = pion;
        }
        //system("pause");
    }
}
 
 
 
// main function (exe hInstance)
int APIENTRY _tWinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPTSTR    lpCmdLine,
    int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
    value = 0;
    
    // tu powinna byc tez funkcja Wczytaj_roll_pitch_yaw(), bo bez jej zrobienia nie ruszymy dalej :(
    Wczytaj_roll_pitch_yaw();
    //przesun_kat_dla_grafu(j, vec); 
    licz_obroty(j);
 
 
    
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR           gdiplusToken;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_DRAW, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
 
 
    // Perform application initialization:
    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_DRAW));
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    GdiplusShutdown(gdiplusToken);
 
    return (int)msg.wParam;
}