src/FcNN_test.h - master - vTech/FcApps

src/FcNN_test.h
274 строки9 KB
vTech
alpha_00
03 дек 2025, 17:45
03 дек 2025, 17:45ab8382d
#ifndef _FCNN_TEST_H_
#define _FCNN_TEST_H_

#include "../../FcLibs/FcNN/src/FcNN.h"

//#include "FcLib.h"

const char* mFcTest_NN_Pixel_vertex = "#version 430\n"
"in vec2 aPosition;"
"in vec2 aTexCoord;"
"uniform mat4 uMVP;"
"uniform vec2 uMouse;"
"out mat4 fView;"
"out vec2 fMouse;"
"out vec2 fTexCoord;"
"void main(){"
"fMouse = uMouse;"
"fTexCoord = aTexCoord;"
"gl_Position = vec4(aPosition, 0, 1);"
"}";

const char* mFcTest_NN_Pixel_fragment = "#version 430\n"
"#define STEP 16.0\n"
"#define FSTEP (1.0 / (STEP))\n"
"in vec2 fTexCoord;"
"in vec2 fMouse;"
"uniform sampler2D sTexture;"
"out vec4 FragColor;"
"void main(){"
"	FragColor = texture(sTexture, fTexCoord).rgba;\n"
"}";

typedef struct _FcNN_test_t {
    FcUI_t          mUI;
    FcNN_t*         mNN;

    size_t  mOffsetPoints;
    float   mPoints[200][2];
    float   mTypePoint[200][2];

    FcUI_Buffer_v2_GL_t mBuffer;
    FcGL_Program_t      mProgram;
    FcGL_Texture_2D_t   mTexture;
}FcNN_test_t;

void FcNN_test_updateImage(FcWindow_t* pWindow, FcNN_test_t* pTest) {
    FcNN_Train_Config_t mTrainConfig;
    const FcPlatform_GL_t* mPlatform;
    ptrdiff_t mWidth, mHeight;
    mPlatform = FcWindow_getPlatform_GL(pWindow);
    mWidth = FcWindow_getClientWidth(pWindow);
    mHeight = FcWindow_getClientHeight(pWindow);
    uint8_t* mImage = (uint8_t*)malloc(mHeight * mWidth * 4 * sizeof(uint8_t));
    float mInput[2];
    float* mOutput;



    for (ptrdiff_t y = 0; y < mHeight; y++)
        for (ptrdiff_t x = 0; x < mWidth; x++) {
            mInput[0] = ((float)(mWidth - x) / mWidth  - 0.5);
            mInput[1] = ((float)y / mHeight - 0.5);
            mOutput = FcNN_forward(pTest->mNN, mInput, 2);

            float mGreen = mOutput[1] - mOutput[0] > 0 ? mOutput[0] : 0;
            float mBlue = mOutput[1] - mOutput[0] < 0 ?  mOutput[1] : 0;

            mImage[(y * mWidth + x) * 4 + 0] = 0;
            mImage[(y * mWidth + x) * 4 + 1] = 255 * min(1, max(0, mGreen));
            mImage[(y * mWidth + x) * 4 + 2] = 255 * min(1, max(0, mBlue));
            mImage[(y * mWidth + x) * 4 + 3] = 255;

        }

    for (ptrdiff_t i = 0; i < pTest->mOffsetPoints; i++) {
        ptrdiff_t _x = (pTest->mPoints[i][0] + 0.5) * mWidth;
        ptrdiff_t _y = (pTest->mPoints[i][1] + 0.5) * mHeight;
        for (ptrdiff_t y = -1 + _y; y <= 1 + _y; y++) {
            for (ptrdiff_t x = -1 + _x; x <= 1 + _x; x++) {
                if (pTest->mTypePoint[i][0])
                    mImage[(y * mWidth + x) * 4 + 0] = 63;
                if (pTest->mTypePoint[i][1])
                    mImage[(y * mWidth + x) * 4 + 1] = 63;
            }
        }
    }

    mTrainConfig.mNumberTrain = pTest->mOffsetPoints;
    mTrainConfig.mLengthVector = 2;
    mTrainConfig.mTrainData = (float*)pTest->mPoints;
    mTrainConfig.mTargetData = (float*)pTest->mTypePoint;

    FcNN_train(pTest->mNN, &mTrainConfig);

    FcGL_Texture_2D_copy(mPlatform, &pTest->mTexture, mImage, mWidth, mHeight);
    free(mImage);
}

size_t FcNN_testInitGL(FcWindow_t* pWindow, void* data) {
    size_t mWidth, mHeight;
    const FcPlatform_GL_t* mPlatform;
    FcWindow_Error_t mWindowError;
    FcNN_Config_t mConfig;
    FcGL_Texture_2D_Config_t mTextureConfig;
    FcUI_Buffer_v2_GL_config_t mBufferConfig;
    float mVertex[16];
    int mIndex[6];
    FcNN_test_t* mTest =(FcNN_test_t*)data;
    //mTrainConfig.mNumberTrain = 200;
    //mTrainConfig.mLengthVector = 2;
    //mTrainConfig.mTrainData = &mXY[0][0];
    //mTrainConfig.mTargetData = &mTest[0][0];

    FcNN_Config(&mConfig, 0.001, 2, 1);
    FcNN_Config_pushConnected(&mConfig, 2, NN_LOGISTIC);
    FcNN_Config_pushConnected(&mConfig, 8, NN_LOGISTIC);
    FcNN_Config_pushConnected(&mConfig, 3, NN_LOGISTIC);
    FcNN_Config_pushConnected(&mConfig, 2, NN_LOGISTIC);

    //mTrainConfig.mLengthVector = 0;
    //mTrainConfig.mNumberEpoche = 0;
    //mTrainConfig.mNumberTrain = 0;

    mTest->mNN = FcNN(&mConfig);
    //FcNN_print(mTest->mNN);

    mPlatform = FcWindow_getPlatform_GL(pWindow);

    FCUISAFECALLF(mWindowError, FcGL_Program(mPlatform, mFcTest_NN_Pixel_vertex, NULL, NULL, mFcTest_NN_Pixel_fragment, NULL, &mTest->mProgram));

    mBufferConfig.mWindow = pWindow;
    mBufferConfig.mNameAttrib[0] = "aPosition";
    mBufferConfig.mNameAttrib[1] = "aTexCoord";
    mBufferConfig.mProgram = &mTest->mProgram;
    mBufferConfig.mData = mVertex;
    mBufferConfig.mIndex = mIndex;
    mBufferConfig.mDataSize = 16 * sizeof(float);
    mBufferConfig.mIndexSize = 6 * sizeof(int);
    mBufferConfig.mAttribVectorLength[0] = 2;
    mBufferConfig.mAttribVectorLength[1] = 2;


    _FcUI_RectangleGL_v2f(&mVertex, &mIndex, 0, 0, 2, 2);
    FcUI_Buffer_v2_GL(&mTest->mBuffer, &mBufferConfig);

    mWidth = FcWindow_getClientWidth(pWindow);
    mHeight = FcWindow_getClientHeight(pWindow);

    mTextureConfig.mWidth = mWidth;
    mTextureConfig.mHeight = mHeight;
    mTextureConfig.mFilter = FcGL_Texture_Filter_LINEAR;
    mTextureConfig.mFormat = FcGL_Texture_Format_RGBA;
    mTextureConfig.mWrap = FcGL_Texture_WRAP_EDGE;
    mTextureConfig.mData = NULL;

    FcGL_Texture_2D(mPlatform, &mTest->mTexture, &mTextureConfig); 
    
    mWidth = FcWindow_getClientWidth(pWindow);
    mHeight = FcWindow_getClientHeight(pWindow);
    //uint8_t* mImage = (uint8_t*)calloc(1, mHeight * mWidth * 4 * sizeof(uint8_t));
    ////for (size_t y = 0; y < mHeight; y++) {
    ////    for (size_t x = 0; x < mWidth; x++)
    ////        for (size_t i = 0; i < 4; i++)
    ////        {
    ////            mImage[(y * mWidth + x) * 4 + i] = 0;
    ////        }
    ////}
    //FcGL_Texture_2D_copy(mPlatform, &mTest->mTexture, mImage, mWidth, mHeight);
    //free(mImage);

gError:
    FcNN_Config_free(&mConfig);
    return 0;
}

size_t FcNN_testDrawGL(FcWindow_t* pWindow, void* data) {
    FcNN_test_t* mTest = (FcNN_test_t*)data;
    const FcPlatform_GL_t* pPlatform_GL = FcWindow_getPlatform_GL(pWindow);

    FcNN_test_updateImage(pWindow, mTest);

    FcGL_Program_use(pPlatform_GL, &mTest->mProgram);
    FcUI_Buffer_v2_GL_bind_queue(pWindow, &mTest->mBuffer);
    FcGL_Texture_2D_bind(FcWindow_getPlatform_GL(pWindow), &mTest->mTexture);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

    return 0;
}

void FcNN_testInput(FcUI_Input_data_t* pInput, void* pUI) {
    FcUI_t* mUI = (FcUI_t*)pUI;

    FcNN_test_t* mTest = (FcNN_test_t*)mUI->mInput.mData0;

    float mWidth = FcUI_Window_getClientWidth(&mUI->mWindow);
    float mHeight = FcUI_Window_getClientHeight(&mUI->mWindow);



    switch (pInput->mType) {
    case FCUI_INPUT_DEVICE_MOUSE:
        if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Left_PRESS) {
            mTest->mPoints[mTest->mOffsetPoints][0] = pInput->mEvent.mMouse.x / mWidth - 0.5;
            mTest->mPoints[mTest->mOffsetPoints][1] = pInput->mEvent.mMouse.y / mHeight - 0.5;
            mTest->mTypePoint[mTest->mOffsetPoints][0] = 1;
            mTest->mOffsetPoints += mTest->mOffsetPoints < 199 ? 1 : 0;
        }
        else if (pInput->mEvent.mMouse.mouseKeyCode & FCWINDOW_MOUSE_Right_PRESS) {
            mTest->mPoints[mTest->mOffsetPoints][0] = pInput->mEvent.mMouse.x / mWidth - 0.5;
            mTest->mPoints[mTest->mOffsetPoints][1] = pInput->mEvent.mMouse.y / mHeight - 0.5;
            mTest->mTypePoint[mTest->mOffsetPoints][1] = 1;
            mTest->mOffsetPoints += mTest->mOffsetPoints < 199 ? 1 : 0;

        }
        break;
    case FCUI_INPUT_DEVICE_KEYBOARD:
        if (pInput->mEvent.mKeyboard.keyEvent == FCWINDOW_KEYBOARD_PRESS) {

            break;
        }
    }
    //FcImage_RGBA_free(mImage);
}

void FcNN_Init(FcPlatform_t* pPlatform) {
	FcUI_Setting_t mUI_Config;
	FcUI_Font_Config_t mFontConfig;
	//FcUI_Object_TextView_t mTextView;
	//FcUI_Object_Button_t mButton;

    FcNN_test_t mTest = { 0 };
    FcError_t mError = FCERROR_NOERROR;

    mUI_Config.mWindowConfig.mY = 100;
    mUI_Config.mWindowConfig.mX = 100;
    mUI_Config.mWindowConfig.mWidth = 1024;
    mUI_Config.mWindowConfig.mHeight = 800;
    mUI_Config.mWindowConfig.mVSync = 1;
    mUI_Config.mWindowConfig.mFullscreen = false;
    mUI_Config.mGraphicsSetting.mTypeConfig = FCUI_CONFIG_GRAPHICS_GL_0;
    mUI_Config.mGraphicsSetting.pResizeWindow = NULL;
    mUI_Config.mGraphicsSetting.mData = NULL;

	FCUISAFECALLF(mError, FcUI_Object(&mUI_Config.mObjects));

	mFontConfig.mType = FCUI_FONT_ATLAS_SDF;
	mFontConfig.mData.mBasic.mHeight = 2048;
	mFontConfig.mData.mBasic.mWidth = 2048;
	mFontConfig.mData.mBasic.mPixelHeight = 128;
	memcpy(mFontConfig.mFontName, TEXT("C:\\Windows\\Fonts\\Inkfree.ttf"), sizeof(TEXT("C:\\Windows\\Fonts\\Inkfree.ttf")));

	FcUI_Object_add_font(&mUI_Config.mObjects, &mFontConfig);

	FcUI_Input_t mInput;
	mInput.mFunction = &FcNN_testInput;
    mInput.mData0 = &mTest;
	for (size_t i = 0; i < 1; i++) {
		FCUISAFECALLF(mError, FcUI(&mTest.mUI, pPlatform, &mUI_Config));
		FCUISAFECALLF(mError, FcUI_set_Input(&mTest.mUI, &mInput));
        FCUISAFECALLF(mError, FcUI_GraphicsQueue_push_funcGL(&mTest.mUI, FcNN_testInitGL, &mTest));
        FCUISAFECALLF(mError, FcUI_GraphicsQueue_sync(&mTest.mUI));
        FCUISAFECALLF(mError, FcUI_set_drawSceneGL(&mTest.mUI, FcNN_testDrawGL, &mTest));
		FCUISAFECALLF(mError, FcUI_dispatch(&mTest.mUI));
		FCUISAFECALLF(mError, FcUI_free(&mTest.mUI));

	}
    gError:
	FcUI_Object_free(&mUI_Config.mObjects);
    return;
}



#endif //_FCNN_TEST_H_