Other Functions

yangsy

About 1401 wordsAbout 5 min

2024-11-08

Caution

The variables such as pDeviceInfo used in this article are defined as global variables. For details, refer to: Initialization to Streaming

Switch Data Stream

Determine Device Resolution Stream Type

bool bSuccess = true;
auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
switch (pDeviceInfo[nDeviceIndex].m_deviceType)
{
    case Synexens::SYDEVICETYPE_CS30_SINGLE:
    case Synexens::SYDEVICETYPE_CS30_DUAL:
    {
        if (itStreamFind != g_mapStreamType.end())
        {
            switch (itStreamFind->second)
            {
                case Synexens::SYSTREAMTYPE_RGBD:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_RAW;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RAW, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                default:
                {
                    itStreamFind->second = (Synexens::SYStreamType)(itStreamFind->second + 1);
                    if (itStreamFind->second == Synexens::SYSTREAMTYPE_RGBD)
                    {
                        Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                        if (errorCode == Synexens::SYERRORCODE_SUCCESS)
                        {
                            errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RGB, Synexens::SYRESOLUTION_1920_1080);
                            if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                            {
                                bSuccess = false;
                                PrintCodeInfo("SetFrameResolution RGB", errorCode);
                            }
                        }
                        else
                        {
                            bSuccess = false;
                            PrintCodeInfo("SetFrameResolution Depth", errorCode);
                        }
                    }
                    break;
                }
            }
        }
        break;
    }
    case Synexens::SYDEVICETYPE_CS20_DUAL:
    {
        if (itStreamFind != g_mapStreamType.end())
        {
            switch (itStreamFind->second)
            {
                case Synexens::SYSTREAMTYPE_DEPTHIR:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_RAW;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RAW, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                case Synexens::SYSTREAMTYPE_RAW:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTH;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                case Synexens::SYSTREAMTYPE_DEPTH:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTHIR;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
            }
        }
        break;
    }
    case Synexens::SYDEVICETYPE_CS40:
    {
        if (itStreamFind != g_mapStreamType.end())
        {
            switch (itStreamFind->second)
            {
                case Synexens::SYSTREAMTYPE_DEPTHIR:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTH;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                case Synexens::SYSTREAMTYPE_DEPTH:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTHIR;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
            }
        }
        break;
    }
    case Synexens::SYDEVICETYPE_CS20_SINGLE:
    case Synexens::SYDEVICETYPE_CS20_P:
    {
        if (itStreamFind != g_mapStreamType.end())
        {
            switch (itStreamFind->second)
            {
                case Synexens::SYSTREAMTYPE_DEPTHIR:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_RAW;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RAW, Synexens::SYRESOLUTION_320_240);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                case Synexens::SYSTREAMTYPE_RAW:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTH;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_320_240);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                case Synexens::SYSTREAMTYPE_DEPTH:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTHIR;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_320_240);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
            }
        }
        break;
    }
    case Synexens::SYDEVICETYPE_CS40PRO:
    {
        if (itStreamFind != g_mapStreamType.end())
        {
            switch (itStreamFind->second)
            {
                case Synexens::SYSTREAMTYPE_RGBD:
                {
                    itStreamFind->second = Synexens::SYSTREAMTYPE_DEPTH;
                    Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                    {
                        bSuccess = false;
                        PrintCodeInfo("SetFrameResolution RAW", errorCode);
                    }
                    break;
                }
                default:
                {
                    itStreamFind->second = (Synexens::SYStreamType)(itStreamFind->second + 1);
                    if (itStreamFind->second == Synexens::SYSTREAMTYPE_RGBD)
                    {
                        Synexens::SYErrorCode errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                        if (errorCode == Synexens::SYERRORCODE_SUCCESS)
                        {
                            errorCode = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID
, Synexens::SYFRAMETYPE_RGB, Synexens::SYRESOLUTION_1600_1200);
                            if (errorCode != Synexens::SYERRORCODE_SUCCESS)
                            {
                                bSuccess = false;
                                PrintCodeInfo("SetFrameResolution RGB", errorCode);
                            }
                        }
                        else
                        {
                            bSuccess = false;
                            PrintCodeInfo("SetFrameResolution Depth", errorCode);
                        }
                    }
                    break;
                }
            }
        }
        break;
    }
}

ChangeStreaming Switch Stream Type

if (bSuccess)
{
    Synexens::SYErrorCode errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
    if (errorCodeChangeResolution == Synexens::SYERRORCODE_SUCCESS)
    {
    }
    else
    {
        PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
    }
}

Switch Resolution

Switch to High Resolution

void SwitchHighResolution(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount; nDeviceIndex++)
    {
        switch (pDeviceInfo[nDeviceIndex].m_deviceType)
        {
            case Synexens::SYDEVICETYPE_CS30_SINGLE:
            case Synexens::SYDEVICETYPE_CS30_DUAL:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    if (itStreamFind->second != Synexens::SYSTREAMTYPE_RGBD)
                    {
                        Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution Depth Low", errorCodeChangeResolution);
                        }
                        errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RGB, Synexens::SYRESOLUTION_1920_1080);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution RGB Low", errorCodeChangeResolution);
                        }
                        errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                        }
                    }
                }
                break;
            }
            case Synexens::SYDEVICETYPE_CS20_DUAL:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution Depth Low", errorCodeChangeResolution);
                    }
                    errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                    }
                    break;
                }
            }
            case Synexens::SYDEVICETYPE_CS40:
            case Synexens::SYDEVICETYPE_CS40PRO:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_640_480);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution Depth High", errorCodeChangeResolution);
                    }
                    errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                    }
                    break;
                }
            }
        }
    }
}

Switch to Low Resolution

void SwitchLowResolution(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount; nDeviceIndex++)
    {
        switch (pDeviceInfo[nDeviceIndex].m_deviceType)
        {
            case Synexens::SYDEVICETYPE_CS30_SINGLE:
            case Synexens::SYDEVICETYPE_CS30_DUAL:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    if (itStreamFind->second != Synexens::SYSTREAMTYPE_RGBD)
                    {
                        Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_320_240);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution Depth Low", errorCodeChangeResolution);
                        }
                        errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_RGB, Synexens::SYRESOLUTION_640_480);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution RGB Low", errorCodeChangeResolution);
                        }
                        errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                        if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                        {
                            PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                        }
                    }
                }
                break;
            }
            case Synexens::SYDEVICETYPE_CS20_DUAL:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_320_240);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution Depth Low", errorCodeChangeResolution);
                    }
                    errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                    }
                    break;
                }
            }
            case Synexens::SYDEVICETYPE_CS40:
            case Synexens::SYDEVICETYPE_CS40PRO:
            {
                auto itStreamFind = g_mapStreamType.find(pDeviceInfo[nDeviceIndex].m_nDeviceID);
                if (itStreamFind != g_mapStreamType.end())
                {
                    Synexens::SYErrorCode errorCodeChangeResolution = Synexens::SetFrameResolution(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYFRAMETYPE_DEPTH, Synexens::SYRESOLUTION_320_240);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution Depth Low", errorCodeChangeResolution);
                    }
                    errorCodeChangeResolution = Synexens::ChangeStreaming(pDeviceInfo[nDeviceIndex].m_nDeviceID, itStreamFind->second);
                    if (errorCodeChangeResolution != Synexens::SYERRORCODE_SUCCESS)
                    {
                        PrintCodeInfo("ChangeFrameResolution ChangeStreaming", errorCodeChangeResolution);
                    }
                    break;
                }
            }
        }
    }
}

Adjust Integration Time

Increase Integration Time

void UpIntegralTimeRange(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    int* pIntegralTimeMin = new int[nDeviceCount];
    int* pIntegralTimeMax = new int[nDeviceCount];
    int* pIntegralTime = new int[nDeviceCount];

    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount
; nDeviceIndex++)
    {
        Synexens::SYErrorCode errorCodeIntegralTime = Synexens::GetIntegralTimeRange(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYRESOLUTION_640_480, pIntegralTimeMin[nDeviceIndex], pIntegralTimeMax[nDeviceIndex]);
        if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetIntegralTimeRange success, Min = %d, Max = %d\n", pIntegralTimeMin[nDeviceIndex], pIntegralTimeMax[nDeviceIndex]);
        }
        else
        {
            PrintCodeInfo("GetIntegralTimeRange", errorCodeIntegralTime);
        }
        errorCodeIntegralTime = Synexens::GetIntegralTime(pDeviceInfo[nDeviceIndex].m_nDeviceID, pIntegralTime[nDeviceIndex]);
        if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetIntegralTime success, nIntegralTime = %d\n", pIntegralTime[nDeviceIndex]);
        }
        else
        {
            PrintCodeInfo("GetIntegralTime", errorCodeIntegralTime);
        }
        if (pIntegralTime[nDeviceIndex] >= pIntegralTimeMax[nDeviceIndex])
        {
            printf("IntegralTime already be Max\n");
        }
        else
        {
            pIntegralTime[nDeviceIndex] += 100;
            if (pIntegralTime[nDeviceIndex] >= pIntegralTimeMax[nDeviceIndex])
                pIntegralTime[nDeviceIndex] = pIntegralTimeMax[nDeviceIndex];
            Synexens::SYErrorCode errorCodeIntegralTime = Synexens::SetIntegralTime(pDeviceInfo[nDeviceIndex].m_nDeviceID, pIntegralTime[nDeviceIndex]);
            if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
            {
                printf("SetIntegralTime success, nIntegralTime = %d\n", pIntegralTime[nDeviceIndex]);
            }
            else
            {
                PrintCodeInfo("SetIntegralTime", errorCodeIntegralTime);
            }
        }
    }

    delete[] pIntegralTimeMin;
    delete[] pIntegralTimeMax;
    delete[] pIntegralTime;
}

Decrease Integration Time

void DownIntegralTimeRange(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    int* pIntegralTimeMin = new int[nDeviceCount];
    int* pIntegralTimeMax = new int[nDeviceCount];
    int* pIntegralTime = new int[nDeviceCount];

    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount; nDeviceIndex++)
    {
        Synexens::SYErrorCode errorCodeIntegralTime = Synexens::GetIntegralTimeRange(pDeviceInfo[nDeviceIndex].m_nDeviceID, Synexens::SYRESOLUTION_640_480, pIntegralTimeMin[nDeviceIndex], pIntegralTimeMax[nDeviceIndex]);
        if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetIntegralTimeRange success, Min = %d, Max = %d\n", pIntegralTimeMin[nDeviceIndex], pIntegralTimeMax[nDeviceIndex]);
        }
        else
        {
            PrintCodeInfo("GetIntegralTimeRange", errorCodeIntegralTime);
        }
        errorCodeIntegralTime = Synexens::GetIntegralTime(pDeviceInfo[nDeviceIndex].m_nDeviceID, pIntegralTime[nDeviceIndex]);
        if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetIntegralTime success, nIntegralTime = %d\n", pIntegralTime[nDeviceIndex]);
        }
        else
        {
            PrintCodeInfo("GetIntegralTime", errorCodeIntegralTime);
        }
        if (pIntegralTime[nDeviceIndex] <= pIntegralTimeMin[nDeviceIndex])
        {
            printf("IntegralTime already be Min\n");
        }
        else
        {
            pIntegralTime[nDeviceIndex] -= 100;
            if (pIntegralTime[nDeviceIndex] <= pIntegralTimeMin[nDeviceIndex])
                pIntegralTime[nDeviceIndex] = pIntegralTimeMin[nDeviceIndex];
            Synexens::SYErrorCode errorCodeIntegralTime = Synexens::SetIntegralTime(pDeviceInfo[nDeviceIndex].m_nDeviceID, pIntegralTime[nDeviceIndex]);
            if (errorCodeIntegralTime == Synexens::SYERRORCODE_SUCCESS)
            {
                printf("SetIntegralTime success, nIntegralTime = %d\n", pIntegralTime[nDeviceIndex]);
            }
            else
            {
                PrintCodeInfo("SetIntegralTime", errorCodeIntegralTime);
            }
        }
    }

    delete[] pIntegralTimeMin;
    delete[] pIntegralTimeMax;
    delete[] pIntegralTime;
}

Mirror and Flip

Horizontal Mirror

void HorizontalMirror(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount; nDeviceIndex++)
    {
        bool bMirror = false;
        Synexens::SYErrorCode errorCodeMirror = Synexens::GetMirror(pDeviceInfo[nDeviceIndex].m_nDeviceID, bMirror);
        if (errorCodeMirror == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetMirror success, bMirror = %d\n", bMirror);
        }
        else
        {
            PrintCodeInfo("GetMirror", errorCodeMirror);
        }
        bMirror = !bMirror;
        errorCodeMirror = Synexens::SetMirror(pDeviceInfo[nDeviceIndex].m_nDeviceID, bMirror);
        if (errorCodeMirror == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("SetMirror success, bMirror = %d\n", bMirror);
        }
        else
        {
            PrintCodeInfo("SetMirror", errorCodeMirror);
        }
    }
}

Vertical Flip

void FlipVertical(int nDeviceCount, Synexens::SYDeviceInfo* pDeviceInfo)
{
    for (int nDeviceIndex = 0; nDeviceIndex < nDeviceCount; nDeviceIndex++)
    {
        bool bFlip = false;
        Synexens::SYErrorCode errorCodeFlip = Synexens::GetFlip(pDeviceInfo[nDeviceIndex].m_nDeviceID, bFlip);
        if (errorCodeFlip == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("GetFlip success, bFlip = %d\n", bFlip);
        }
        else
        {
            PrintCodeInfo("GetFlip", errorCodeFlip);
        }
        bFlip = !bFlip;
        errorCodeFlip = Synexens::SetFlip(pDeviceInfo[nDeviceIndex].m_nDeviceID, bFlip);
        if (errorCodeFlip == Synexens::SYERRORCODE_SUCCESS)
        {
            printf("SetFlip success, bFlip = %d\n", bFlip);
        }
        else
        {
            PrintCodeInfo("SetFlip", errorCodeFlip);
        }
    }
}