Lab5555

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#ifdef _MSC_VER
#  include <intrin.h>
#  define __builtin_popcount __popcnt
#endif

#define ISBIT(n,x) (((01<<(n))&(x))?1:0)

void outbyte(char byte)
{
    int i;
    for (i = 7; i > -1; i--)
        putchar(ISBIT((i), byte) ? '*' : ' ');
    fflush(stdout);
}

void outbytes(int n, char* byte)
{
    int i;
    for (i = 0; i < n; i++)
        outbyte(byte[i]);
    putchar('\n');
}



typedef struct img {
    int w; int h;  // ширина, высота глифа
    int dx;     //хз
    int count;   //кол-во черных пикселей
    int id;      //номер глифа
    int bytes;  //количество байтов
    double density; //плотность черных пикселей
    int diam; //диаметр(самое большое расстояние межуду чеными пикселями), нужно найти
    int perim; //периметр
    int conn; //кол-во слияний
    unsigned char* data; //битовая карта
} IMG;

int popcnt16(unsigned short int i)
{
    return __builtin_popcount(i);
    //   i = i - ((i >> 1) & 0x5555);
    //   i = (i & 0x3333) + ((i >> 2) & 0x3333);
    //   return (((i + (i >> 4)) & 0x0F0F) * 0x0101) >> 8;
}
int popcnt8(unsigned char i)
{
    int count;
    count = 0;
    while (i)
    {
        ++count;
        i = (i - 1) & i;
    }
    return count;
}
int popcnt64(unsigned long long w) {
    //  return __builtin_popcountll(w);
    w -= (w >> 1) & 0x5555555555555555ULL;
    w = (w & 0x3333333333333333ULL) + ((w >> 2) & 0x3333333333333333ULL);
    w = (w + (w >> 4)) & 0x0f0f0f0f0f0f0f0fULL;
    return (int)((w * 0x0101010101010101ULL) >> 56);
}
int popcnt32(unsigned int i)
{
    //   return __builtin_popcountl(i);
    i = i - ((i >> 1) & 0x55555555);
    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
    return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}


IMG* init_img(int id, int w, int h)
{
    IMG* t;
    t = (IMG*)malloc(sizeof(IMG));
    t->w = w; t->h = h; t->dx = 0;
    t->count = 0;
    t->id = id;
    t->bytes = (((w + 7) / 8) * h);
    t->data = (unsigned char*)calloc(t->bytes, 1);
    return t;
}



IMG* load_img(int id, char* s)
{
    FILE* F;
    IMG* I;
    I = (IMG*)malloc(sizeof(IMG));
    F = fopen(s, "rb");
    fread(&(I->w), sizeof(int), 1, F);
    fread(&(I->h), sizeof(int), 1, F);
    fread(&(I->dx), sizeof(int), 1, F);
    fread(&(I->count), sizeof(int), 1, F);
    fread(&(I->id), sizeof(int), 1, F);
    fread(&(I->bytes), sizeof(int), 1, F);
    I->data = (unsigned char*)calloc(I->bytes, 1);
    fread(I->data, 1, I->bytes, F);
    fclose(F);
    I->conn = 0;
    I->perim = 0;
    return I;
}
int xcomp(IMG** a, IMG** b)
{
    return  -(*a)->w + (*b)->w;
}
int ycomp(IMG** a, IMG** b)
{
    return  -(*a)->h + (*b)->h;
}

IMG* G[50000];
int N;
bool matr[100][100];
bool flag[100][100];

int ISPIX(int argc, int i, int j)
{
    if (i < 0) return 0;
    if (j < 0) return 0;
    if (i >= G[argc]->w) return 0;
    if (j >= G[argc]->h) return 0;

    return ISBIT((7 - j % 8), G[argc]->data[i * (G[argc]->bytes / G[argc]->h) + j / 8]);
}

int offset[4][2] = { {-1, 0 }, { 0, -1 }, { 0, 1 }, { 1, 0 } };

double N_density(int h, int w, int count)// плотность писелей
{
    double co = count;
    return co / (h * w);
}

void dfs(int i, int j, int h, int w)//это бфс, тут ничего не нужно
{
    if (i < 0 || i >= h || j < 0 || j >= w || flag[i][j] || !matr[i][j])
    {
        return;
    }

    flag[i][j] = true;
    dfs(i - 1, j, h, w);
    dfs(i + 1, j, h, w);
    dfs(i, j - 1, h, w);
    dfs(i, j + 1, h, w);
}

int perim(int i, int j, int h, int w) //тут периметр, тоже ничего не нужно
{
    int k;
    int p = 0;
    bool f = false;

    for (k = 0; k < 4; k++)
    {
        int tmpi = i + offset[k][0];
        int tmpj = j + offset[k][1];

        if (!matr[tmpi][tmpj] || (tmpi < 0 || tmpj < 0 || tmpi >= h || tmpj >= w))
        {
            f = true;
        }
    }

    if (f)
    {
        p++;
    }
    return p;
}

int bfs(int h, int w)  //это диаметр, но она не робит, можешь попробовать доделать или переделать
{
    int i, j;

    for (i = 0; i < h; i++)
    {
        for (j = 0; j < w; j++)
        {
            if (!matr[i][j])
            {
                continue;
            }

            //stack[0] = i * w + j;
            //size++;

        }
    }
}

int main(int argc, char* argv[])
{
    long int c;
    int len, i, j, k;
    unsigned char* s;
    unsigned long long* t;
    N = argc - 1;

    for (argc--; argc; argc--)
    {
        G[argc] = load_img(argc, argv[argc]);
        printf("Loaded %s\n", argv[argc]); //зарузка глифа

        c = 0;
        t = (unsigned long long*)G[argc]->data;
        s = (unsigned char*)G[argc]->data; // на это забей, я не знаю что это оно тут было изначально

        len = G[argc]->bytes;//длина

        for (int i = 0; i < len / 8; i++)
            c += popcnt64(t[i]);

        for (int i = (len / 8) * 8; i < len; i++)
            c += popcnt8(s[i]);

        int q = 0;//это q, для создания матрицы
        for (i = 0; i < G[argc]->h; i++)//тут создается матрица булевая где черные - true
        {
            for (j = 0; j < G[argc]->bytes / G[argc]->h; j++)
            {
                char byte = G[argc]->data[q++];
                for (k = 0; k < 8; k++)
                {
                    matr[i][j * 8 + (8 - k)] = ISBIT((k), byte);
                }
            }
        }

        G[argc]->conn = 0;// это слияния или что-то такое, ну тебе это не нужно
        for (i = 0; i < G[argc]->h; i++) //это conn, тут не делай ничего
        {
            for (j = 0; j < G[argc]->w; j++)
            {
                if (matr[i][j] && !flag[i][j])
                {
                    dfs(i, j, G[argc]->h, G[argc]->w);
                    G[argc]->conn++;
                }
            }
        }
        for (int i = 0; i < G[argc]->h; i++)//это вывод глифа на экран
        {
            for (int j = 0; j < G[argc]->w; j++)
            {
                printf(matr[i][j] ? "*" : " ");
            }
            printf("\n");
        }

        for (i = 0; i < G[argc]->h; i++)//посчет периметра
        {
            for (j = 0; j < G[argc]->w; j++)
            {
                if (matr[i][j])
                {
                    G[argc]->perim += perim(i, j, G[argc]->h, G[argc]->w);
                }
            }
        }

        for (i = 0; i < G[argc]->h; i++)//обнуление матрицы
        {
            for (j = 0; j < G[argc]->w; j++)
            {
                flag[i][j] = false;
                matr[i][j] = false;
            }
        }

        G[argc]->count = c;

        G[argc]->density = N_density(G[argc]->h, G[argc]->w, G[argc]->count);
        printf("h : %d   w : %d\n", G[argc]->h, G[argc]->w);
        printf("density: %lf\n", G[argc]->density);
        printf("conn: %d\n", G[argc]->conn);
        //printf("diam: %d\n", G[argc]->diam);
        printf("perim: %d\n", G[argc]->perim);

    }
    printf("%d\n", N);
}

//Нужно найти схожие глифы и диаметр