C++ SDK Read images and apply applet

    /*============ ImageInjector : Inject ============== */
    int Device1_Process0_Source_Inject_Mode_Id = Fg_getParameterIdByName(fg, "Device1_Process0_Source_Inject_Mode");
    FG_CHECK(Device1_Process0_Source_Inject_Mode_Id);

    unsigned int Device1_Process0_Source_Inject_Mode;
    Device1_Process0_Source_Inject_Mode = InjectMode::Inject;
    FG_CHECK(Fg_setParameterWithType(fg, Device1_Process0_Source_Inject_Mode_Id, Device1_Process0_Source_Inject_Mode, 0));
...
    // ---------------------------------------------------------------------------
    // Frame Grabber: Grab images
    // ---------------------------------------------------------------------------
    int Device1_Process0_Source_Inject_ReadyForInjection_Id = Fg_getParameterIdByName(fg, "Device1_Process0_Source_Inject_ReadyForInjection");
    FG_CHECK(Device1_Process0_Source_Inject_ReadyForInjection_Id);

    unsigned int ReadyForInjection = -1;

    int Device1_Process0_Source_Inject_ImageFile_Id = Fg_getParameterIdByName(fg, "Device1_Process0_Source_Inject_ImageFile");
    FG_CHECK(Device1_Process0_Source_Inject_ImageFile_Id);

    const char * Inject_ImageFileName = "unset";

    int Device1_Process0_Source_Inject_InjectFromFile_Id = Fg_getParameterIdByName(fg, "Device1_Process0_Source_Inject_InjectFromFile");
    FG_CHECK(Device1_Process0_Source_Inject_InjectFromFile_Id);
...
// within the acquisition loop, sorry for using fprintf :-)
...
    fprintf(stderr, "Waiting for Injection ready ..");
        do {
            FG_CHECK(Fg_getParameterWithType(fg, Device1_Process0_Source_Inject_ReadyForInjection_Id, &ReadyForInjection, 0));
            fprintf(stderr, ".");
        } while (ReadyForInjection != InjectReady::yes);
        fprintf(stderr, "OK\n");
        auto fn = filename.string();
        Inject_ImageFileName = fn.c_str();
        fprintf(stderr, "Uploading %s ", Inject_ImageFileName);
        FG_CHECK(Fg_setParameterWithType(fg, Device1_Process0_Source_Inject_ImageFile_Id, Inject_ImageFileName, 0));
        fprintf(stderr, "...", Inject_ImageFileName);
        int Device1_Process0_Source_Inject_InjectFromFile = InjectReady::yes;
        FG_CHECK(Fg_setParameterWithType(fg, Device1_Process0_Source_Inject_InjectFromFile_Id, Device1_Process0_Source_Inject_InjectFromFile, 0));
        fprintf(stderr, " OK\n");

        fprintf(stderr, "Sending ... ", Inject_ImageFileName);
        Device1_Process0_Source_RUN_Mode = SetSignalStatus::Pulse;
        FG_CHECK(Fg_setParameterWithType(fg, Device1_Process0_Source_RUN_Mode_Id, Device1_Process0_Source_RUN_Mode, 0));
        fprintf(stderr, "OK\n");

        int timeout_secs = 1; // because of file upload and start requiring time
        frameNo0 = Fg_getLastPicNumberBlockingEx(fg, frameNo0 + 1, 0, timeout_secs, pmem0);

        void *iPtr0 = Fg_getImagePtrEx(fg, frameNo0, 0, pmem0);

        // save file nicely, suing openCV function for save. SiSo IO will work similar
        cv::Mat result(height0, width0, CV_8UC1, iPtr0);
        auto targetFilename = filename.filename();
        auto targetPath = filename.parent_path().string() + "/Runtime/";
        auto target = targetPath + targetFilename.string();
        cv::imwrite(target, result);

#ifndef SISO_HELPER
#define SISO_HELPER

/// definition of helper macros
#define __STR2__(x) #x
#define __STR1__(x) __STR2__(x)

/// useful for a pragma message/logging for conditions raised at compile time
// this indicates the file where something may be strange
#define __LOC__ __FILE__ "("__STR1__(__LINE__)") : warning/info SISO: "

/// the function checkReturn could be implemented without macro using std::source_location
#pragma message(__LOC__ "Please change this to std::source_location with C++20") // https://en.cppreference.com/w/cpp/utility/source_location

/// dangerous but simple helper macro for return code interpretation of SGC function, named Sgc_* and derived from SisoGeniCam
#define SGC_CHECK(x) { \
                        int r = (x); \
                        if (r < SGC_OK) \
                        { \
                            checkReturn(r, std::string(__FILE__), __LINE__, std::string(#x), true); \
                        } \
                     }

/// dangerous but simple helper macro for return code interpretation of FG function, named Fg_* and derived from FrameGrabber
#define FG_CHECK(x) { \
                        int r = (x); \
                        if (r < FG_OK) \
                        { \
                            checkReturn(r, std::string(__FILE__), __LINE__, std::string(#x), false); \
                        } \
                    }

/// dangerous but simple helper macro for return(incl. return) code interpretation of FG function, named Fg_* and derived from FrameGrabber
#define FG_RETURN(x) checkReturn((x), std::string(__FILE__), __LINE__, std::string(#x), false)

/// dangerous but simple helper macro for return(incl. return) code interpretation of SGC function, named Sgc_* and derived from SisoGeniCam
#define SGC_RETURN(x) checkReturn((x), std::string(__FILE__), __LINE__, std::string(#x), true)

#endif // SISO_HELPER

int checkReturn(int ReturnCode, std::string call_file, unsigned int call_line, std::string call_func, bool sgc)
{
    if (ReturnCode < (sgc ? SGC_OK : FG_OK))
    {
#pragma message(__LOC__ "Please change this to std::source_location with C++20") // https://en.cppreference.com/w/cpp/utility/source_location
        // std::cout << "(checkReturn " << __FILE__ << ":" << __LINE__ << " reporting)"<< std::endl;
        std::cout << "triggered in " << call_file << ": line" << call_line << std::endl << " called function: " << call_func << std::endl << " >> ";
#ifndef NOCAMERA
        std::cout << (sgc ? "GenICam" : "Runtime") << " Error[" << ReturnCode << "]:" << (sgc ? Sgc_getErrorDescription(ReturnCode) : getErrorDescription(ReturnCode)) << std::endl;;
#else
        std::cout << (sgc ? "GenICam(NOT EXPECTED)" : "Runtime") << " Error[" << ReturnCode << "]:" << getErrorDescription(ReturnCode) << std::endl;;
#endif
    }
    return ReturnCode;
}