Lab 14

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <errno.h>
#include <stdlib.h>
#include "graphics.h"

double f(double x); //Подпрограмма, вычисляющая значение функции x^2*exp(-x)
void draw_chart(double a, double b, int x_steps, int y_steps); //Подпрограмма, рисующая график функции x^2*exp(-x)
void draw_histogram(double a, double b, int x_steps, int y_steps); //Подпрограмма, рисующая гистограмму функции x^2*exp(-x)
void save_chart(char* file_name); //Подпрограмма, рисующая и сохраняющая гистограмму функции x^2*exp(-x)

/*struct RGBQUAD
{
    unsigned char rgbBlue;
    unsigned char rgbGreen;
    unsigned char rgbRed;
    unsigned char rgbReserved;
};*/

/*struct BITMAPFILEHEADER
{

    unsigned short int bfType;
    unsigned long bfSize;
    unsigned short int bfReserved1;
    unsigned short int bfReserved2;
    unsigned long bfOffBits;
};*/

/*struct BITMAPINFOHEADER
{
    unsigned long biSize;
    long biWidth;
    long biHeight;
    unsigned short int biPlanes;
    unsigned short int biBitCount;
    unsigned long biCompression;
    unsigned long biSizeImage;
    long biXPelsPerMeter;
    long biYPelsPerMeter;
    unsigned long biClrUsed;
    unsigned long biClrImportant;
};*/

RGBQUAD get_ega_color(int color);
int main()
{
    int res;
    double a = -1, b = 2;

    int gdriver = DETECT, gmode;
    initgraph(&gdriver, &gmode, ""); //Инициализация графического режима
    res = graphresult();
    if (res != grOk)
    {
        printf("An error has occured while initializing graphicsl output.");
        return -1;
    }

    draw_chart(a, b, 78, 25);
    draw_histogram(a, b, 60, 80);
    save_chart("C:\\test\\out.bmp");
    closegraph(); //Выход из графического режима
    return 0;
}

double f(double x) //Подпрограмма, вычисляющая значение функции x^2*exp(-x)
{
    double ctrl, result;
    result = x * x;
    if (fabs(ctrl = result / x - x) >= 0.00001)
    {
        //TODO: посмотреть, нужно ли errno
        errno = ERANGE;
        return -1;
    }
    return (result / exp(x));
}

void draw_chart(double a, double b, int x_steps, int y_steps) //Подпрограмма, рисующая график функции x^2*exp(-x)
{
    int i, max_x, max_y, zero_x, zero_y;
    double x, y;
    double top_y, x_inc, del_x, del_y;
    double len = b - a; //Длина отрезка
    double offset_percent; //Процент от максимальных координат, который отступается от осей.

    max_x = getmaxx();
    max_y = getmaxy();

    //Сделать фон белым, а цвет рисования чёрным.
    setfillstyle(1, 15);
    bar(0, 0, max_x, max_y);
    setcolor(0);
    setlinestyle(0, 0, 1);

    offset_percent = 0.1;

    //Вычисляем положение нуля на оси x
    zero_x = max_x * offset_percent;
    if (a < 0)
    {
        zero_x += (fabs(a)/len) * (max_x * (1 - 2 * offset_percent)); //TODO
    }

    zero_y = max_y * (1 - offset_percent);

    line(max_x * offset_percent, zero_y, max_x * (1 - offset_percent), zero_y); //Ось x
    del_x = (max_x * (1 - 2 * offset_percent)) / x_steps;
    for (i = 0; i < x_steps; i++)
    {
        line(max_x * offset_percent + i * del_x, zero_y + 1, max_x * offset_percent + i * del_x, zero_y - 1);
    }

    line(zero_x, zero_y, zero_x, max_y * offset_percent); //Ось y
    del_y = (max_y * (1 - 2 * offset_percent)) / y_steps;
    for (i = 0; i < y_steps; i++)
    {
        line(zero_x - 3, zero_y - del_y * i, zero_x + 3, zero_y - del_y * i);
    }

    //TODO: добавить стрелки
    //TODO: добавить деления
    //TODO: добавить подписи

    offset_percent += 0.03;
    del_x = (max_x * (1 - 2 * offset_percent)) / len; //Цена делания по оси x
    x_inc = len / x_steps;

    top_y = (f(a) > f(b)) ?  f(a) : f (b); //Наибольшее значение по y. TODO: исправить
    del_y = (zero_y - max_y * offset_percent) / top_y; //Цена деления по оси y;

    double prev_x, prev_y, cur_x, cur_y;
    x = a;
    prev_x = x * del_x + zero_x;
    prev_y = zero_y - f(x) * del_y;
    x += x_inc;
    for (i = 1; i < x_steps; i++, x += x_inc)
    {
        cur_x = x * del_x + zero_x;
        cur_y = zero_y - f(x) * del_y;
        line(prev_x, prev_y, cur_x, cur_y);
        prev_x = cur_x;
        prev_y = cur_y;
    }
    system("pause");
}

void draw_histogram(double a, double b, int x_steps, int y_steps)
{
    int i, max_x, max_y, zero_x, zero_y;
    double x, y;
    double top_y, x_inc, del_x, del_y;
    double len = b - a; //Длина отрезка
    double offset_percent; //Процент от максимальных координат, который отступается от осей.

    max_x = getmaxx();
    max_y = getmaxy();

    //Сделать фон белым, а цвет рисования чёрным.
    setfillstyle(1, 15);
    bar(0, 0, max_x, max_y);
    setcolor(0);
    setlinestyle(0, 0, 1);

    offset_percent = 0.1;

    //Вычисляем положение нуля по вертикали (на оси y)
    zero_x = max_y * offset_percent;
    if (a < 0)
    {
        zero_x += (fabs(a) / len) * (max_y * (1 - 2 * offset_percent)); //TODO
    }

    zero_y = max_x * offset_percent;
    line(max_x * offset_percent, zero_x, max_x * (1 - offset_percent), zero_x); //Ось y (горизонтальная)
    line(zero_y, max_y * offset_percent, zero_y, max_y *  (1 - offset_percent)); //Ось x (вертикальная)

    offset_percent += 0.03;
    del_x = (max_y * (1 - 2 * offset_percent)) / len; //Цена деления по оси x (вертикальная)
    x_inc = len / x_steps;

    top_y = (f(a) > f(b)) ? f(a) : f(b); //Наибольшее значение по y. TODO: исправить
    del_y = (max_x * (1 - 2 * offset_percent)) / top_y; //Цена делания по оси y (горизонтальная)


    double prev_x, prev_y, cur_x, cur_y;
    char str[10];
    setbkcolor(WHITE);
    settextstyle(SMALL_FONT, HORIZ_DIR, 3);

    for (x = a, i = 0; i < x_steps; i++, x += x_inc)
    {
        cur_y = zero_y + f(x) * del_y;
        cur_x = zero_x + x * del_x;
        line(zero_y, cur_x, cur_y, cur_x);
        sprintf(str, "%f", f(x));
        outtextxy(cur_y + 10, cur_x - 3, str);
        prev_x = cur_x;
        prev_y = cur_y;
    }

    system("pause");

}

RGBQUAD get_ega_color(int color) {

    RGBQUAD v;
    v.rgbReserved = 0;

    switch (color) {
    case BLACK: v.rgbRed = 0; v.rgbGreen = 0; v.rgbBlue = 0; break;
    case BLUE: v.rgbRed = 0; v.rgbGreen = 0; v.rgbBlue = 128; break;
    case GREEN: v.rgbRed = 0; v.rgbGreen = 128; v.rgbBlue = 0; break;
    case CYAN: v.rgbRed = 0; v.rgbGreen = 128; v.rgbBlue = 128; break;
    case RED: v.rgbRed = 128; v.rgbGreen = 0; v.rgbBlue = 0; break;
    case MAGENTA: v.rgbRed = 128; v.rgbGreen = 0; v.rgbBlue = 128; break;
    case BROWN: v.rgbRed = 128; v.rgbGreen = 64; v.rgbBlue = 0; break;
    case LIGHTGRAY: v.rgbRed = 128; v.rgbGreen = 128; v.rgbBlue = 128; break;
    case DARKGRAY: v.rgbRed = 64; v.rgbGreen = 64; v.rgbBlue = 64; break;
    case LIGHTBLUE: v.rgbRed = 0; v.rgbGreen = 0; v.rgbBlue = 255; break;
    case LIGHTGREEN: v.rgbRed = 0; v.rgbGreen = 255; v.rgbBlue = 0; break;
    case LIGHTCYAN: v.rgbRed = 0; v.rgbGreen = 255; v.rgbBlue = 255; break;
    case LIGHTRED: v.rgbRed = 255; v.rgbGreen = 0; v.rgbBlue = 0; break;
    case LIGHTMAGENTA: v.rgbRed = 255; v.rgbGreen = 0; v.rgbBlue = 255; break;
    case YELLOW: v.rgbRed = 255; v.rgbGreen = 255; v.rgbBlue = 0; break;
    case WHITE: v.rgbRed = 255; v.rgbGreen = 255; v.rgbBlue = 255; break;
    }
    return v;

}
void save_chart(char* file_name)
{//Подпрограмма, рисующая и сохраняющая гистограмму функции x^2*exp(-x)
    //int nWidth = getmaxx() + 1;
    int nWidth = getmaxx();
    //int nHeight = getmaxy() + 1;
    int nHeight = getmaxy();
    FILE *pFile = fopen(file_name, "wb");

    if (pFile == NULL)
    {
        printf("Could not open file");
        return;
    }
    // save bitmap file header
    BITMAPFILEHEADER fileHeader;
    fileHeader.bfType = 0x4d42;
    fileHeader.bfSize = 0;
    fileHeader.bfReserved1 = 0;
    fileHeader.bfReserved2 = 0;
    fileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + 16 * sizeof(RGBQUAD);
    fwrite((char*)&fileHeader, sizeof(fileHeader), 1, pFile);

    // save bitmap info header
    BITMAPINFOHEADER infoHeader;
    infoHeader.biSize = sizeof(infoHeader);
    infoHeader.biWidth = nWidth;
    infoHeader.biHeight = nHeight;
    infoHeader.biPlanes = 1;
    infoHeader.biBitCount = 4;
    infoHeader.biCompression = 0; // BI_RGB
    infoHeader.biSizeImage = 0;
    infoHeader.biXPelsPerMeter = 0;
    infoHeader.biYPelsPerMeter = 0;
    infoHeader.biClrUsed = 16;
    infoHeader.biClrImportant = 16;
    fwrite((char*)&infoHeader, sizeof(infoHeader), 1, pFile);

    // palette output
    RGBQUAD palette[16];
    memset(&palette[0], 16 * sizeof(RGBQUAD), 0);
    for (long clr = 0; clr < 16; clr++) {
        palette[clr] = get_ega_color(clr);
    }
    fwrite((char*)(&palette), 1, 16 * sizeof(RGBQUAD), pFile);

    // raster output
    int maxx = (getmaxx() + 1) / 2;
    int maxy = (getmaxy() - 1); //TODO
    for (int y = maxy; y >= 0; y--) {
        for (int x = 0; x < maxx; x++) {

            // we will place 2 pixels into one byte
            unsigned char pix1 = getpixel(x * 2, y);
            unsigned char pix2 = getpixel(x * 2 + 1, y);
            unsigned char temp = pix2 | (pix1 << 4);
            fwrite(&temp, sizeof(temp), 1, pFile);
        }
    }
    fclose(pFile);
}