int SplitImage2Areas(unsigned char **Image, int **AreasNumb, int *Areas2Mode, int Width, int Height, int Thres1, int Thres2)
{
    if ((Image==0)||(Width<=0)||(Height<=0)||(AreasNumb==0)) return -1;

    int iPrevAreaNumbL=-1;  //Номер области предыдущей левой точки
    int iPrevModeNumbL=-1;  //Номер моды предыдущей левой точки
    int iPrevAreaNumbU=-1;  //Номер области предыдущей верхней точки
    int iPrevModeNumbU=-1;  //Номер моды предыдущей верхней точки
    int iPrevAreaNumbUL=-1; //Номер области предыдущей верхней левой точки
    int iPrevModeNumbUL=-1; //Номер моды предыдущей верхней левой точки
    int iPrevAreaNumbUR=-1; //Номер области предыдущей верхней правой точки
    int iPrevModeNumbUR=-1; //Номер моды предыдущей верхней правой точки
    int iAreasCount=0;      //Счётчик кол-ва областей
    int i, j, y, x, iNumb[4], iNumbCount, iDelta, iTmp;
    int iCurrPixel, iCurrAreaNumb, iCurrModeNumb;
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    for (y=0; y<Height; y++) for (x=0; x<Width; x++)
    {
        //Значение яркости текущего пикселя
        iCurrPixel=Image[y][x];
        //Номер области текущей точки
        iCurrAreaNumb=-1;
        //Номер моды текущей точки
        iCurrModeNumb=(iCurrPixel<Thres1?0:(iCurrPixel>Thres2?1:-1));
        //Определение параметров верхней правой точки
        if ((y>0)&&(x<(Width-1)))
        {
            iPrevAreaNumbUR=AreasNumb[y-1][x+1];
            iPrevModeNumbUR=Areas2Mode[iPrevAreaNumbUR];
        }
        //В зависимости от того является ли точка переходной
        if (iCurrModeNumb>=0)
        {
            //Эта точка не является переходной ни к одной из мод
            //Просмотр всех соседних уже размеченных ранее точек
            //для возможного определения номера области текущей точки
            if ((x>0)&&(iCurrModeNumb==iPrevModeNumbL)) {
                iCurrAreaNumb=iPrevAreaNumbL; //Левая точка
            }
            else if (y>0) { //Верхняя строка
                if (iCurrModeNumb==iPrevModeNumbU) {
                    iCurrAreaNumb=iPrevAreaNumbU; //Верхняя точка
                }
                else if ((x>0)&&(iCurrModeNumb==iPrevModeNumbUL)) {
                    iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
                }
                else if ((x<(Width-1))&&(iCurrModeNumb==iPrevModeNumbUR)) {
                    iCurrAreaNumb=iPrevAreaNumbUR; //Верхняя правая точка
                }
            }
        }
        else
        {
            //Текущая точка является переходной к любой области
            //Выбор наиболее близкой области
            iDelta=iTmp=-1;
            if (x>0) { //Левая точка
                iCurrAreaNumb=iPrevAreaNumbL;
                iDelta=abs(Image[y][x-1]-iCurrPixel);
            }
            if (y>0) { //Верхняя строка
                //Верхняя точка
                iTmp=abs(Image[y-1][x]-iCurrPixel);
                if ((iDelta<0)||(iDelta>iTmp)) {
                    iCurrAreaNumb=iPrevAreaNumbU;
                    iDelta=iTmp;
                }
                if (x>0) { //Верхняя левая точка
                    iTmp=abs(Image[y-1][x-1]-iCurrPixel);
                    if (iDelta>iTmp) {
                        iCurrAreaNumb=iPrevAreaNumbUL;
                        iDelta=iTmp;
                    }
                }
                if (x<(Width-1)) { //Верхняя правая точка
                    iTmp=abs(Image[y-1][x+1]-iCurrPixel);
                    if (iDelta>iTmp) {
                        iCurrAreaNumb=iPrevAreaNumbUR;
                        iDelta=iTmp;
                    }
                }
            }
            //Проверка на верхнюю левую точку всего изображения
            if (iCurrAreaNumb>=0)
                iCurrModeNumb=Areas2Mode[iCurrAreaNumb];
            else
                //Нужно добавить новую область с нулевой модой
                iCurrModeNumb=0;
        }
        //Если это новая область
        if (iCurrAreaNumb<0)
        {
            //Добавление нового объекта в коллекцию
            iCurrAreaNumb=iAreasCount++;
            Areas2Mode[iCurrAreaNumb]=iCurrModeNumb;
        }
        //Установка номера области текущей точки
        AreasNumb[y][x] = iCurrAreaNumb;
        //Сканирование окрестных точек для выяснения граничащих областей
        iNumbCount=0;
        if ((x==0)||(iPrevAreaNumbL!=iCurrAreaNumb))
        {
            //Просмотр левой точки
            if ((x>0)&&(iCurrModeNumb==iPrevModeNumbL)&&(iCurrAreaNumb!=iPrevAreaNumbL))
                iNumb[iNumbCount++]=iPrevAreaNumbL;
            //Просмотр верхней левой точки
            if ((y>0)&&(x>0)&&(iCurrModeNumb==iPrevModeNumbUL)&&(iCurrAreaNumb!=iPrevAreaNumbUL))
                iNumb[iNumbCount++]=iPrevAreaNumbUL;
            //Просмотр верхней точки
            if ((y>0)&&(iCurrModeNumb==iPrevModeNumbU)&&(iCurrAreaNumb!=iPrevAreaNumbU))
                iNumb[iNumbCount++]=iPrevAreaNumbU;
        }
        //Сканирование верхней правой точки (в любом случае независимо от iPrevAreaNumb!!!)
        if ((y>0)&&(x<(Width-1))&&(iCurrModeNumb==iPrevModeNumbUR)&&(iCurrAreaNumb!=iPrevAreaNumbUR))
            iNumb[iNumbCount++]=iPrevAreaNumbUR;
        //Добавление найденных граничных областей
        for (i=0; i<iNumbCount; i++)
        {
            iTmp=iNumb[i];
            bool bFind=false;
            for (j=0; j<i; j++) if (iNumb[j]==iTmp) {
                bFind=true;
                break;
            }
            if (!bFind) {
                //Здесь области добавляются к списку соседних областей
            }
        }
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Запоминание номера области и моды для верхней левой точки
        iPrevAreaNumbUL=iPrevAreaNumbU;
        iPrevModeNumbUL=iPrevModeNumbU;
        //Запоминание номера области и моды для верхней точки
        iPrevAreaNumbU=iPrevAreaNumbUR;
        iPrevModeNumbU=iPrevModeNumbUR;
    }

    return iAreasCount;
}

#include <stdlib.h>

//Максимальное кол-во областей в изображении
#define MAX_AREAS 1000
#define min(x,y) (x<y?x:y)

//Структура хранения информации об областях
typedef struct TAreaInfo
{
    //Номер кластера
    short iNumber;
    //Номер моды
    short iMode;
    //Счётчик мощности моды
    int iCount;
} TAreaInfo;

//Счётчики количества областей в изображении и в контейнере
static int iAreasCount=0, iAreasInfoCount=0;

//Ограниченный массив структур описателей областей!!!
static TAreaInfo AreasInfo[MAX_AREAS+1];

//Таблица соответствия значений пикселов модам гистограммы
static int ModeNumb4Pix[256];

//Функция создания новой области
static inline int AddNewAreaInfo(const int iModeNumb)
{
//    if (iAreasInfoCount>=MAX_AREAS) return -1;
    iAreasCount++;
    AreasInfo[iAreasInfoCount].iMode=iModeNumb;
    AreasInfo[iAreasInfoCount].iNumber=-1;
    AreasInfo[iAreasInfoCount].iCount=0;
    return iAreasInfoCount++;
}

/*!\brief Разбиение изображения на непересекающиеся области
* \param Image - исходное изображение
* \param Height - высота изображения
* \param Width - ширина изображение
* \param AreasNumbBuf - буфер результата, отражающий номера областей каждого из пикселов
* \param Thr1 - нижний порог
* \param Thr2 - верхний порог
* \result Количество непересекающихся областей в изображении
*/
int SplitImage2Areas(
    register unsigned char ** __restrict Image,
    register int Height, register int Width,
    register int ** __restrict AreasNumbBuf,
    register int Thr1, register int Thr2)
{
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    //Вычисление площади, занимаемой каждой областью и модой
    register int iPrevAreaNumbL=-1;  //Номер области предыдущей левой точки
    register int iPrevModeNumbL=-1;  //Номер моды предыдущей левой точки
    register int iPrevAreaNumbU=-1;  //Номер области предыдущей верхней точки
    register int iPrevModeNumbU=-1;  //Номер моды предыдущей верхней точки
    register int iPrevAreaNumbUL=-1; //Номер области предыдущей верхней левой точки
    register int iPrevModeNumbUL=-1; //Номер моды предыдущей верхней левой точки
    register int iPrevAreaNumbUR=-1; //Номер области предыдущей верхней правой точки
    register int iPrevModeNumbUR=-1; //Номер моды предыдущей верхней правой точки
    //Временные переменные
    register int i, y, x, iSrcIndex, iDstIndex, iDelta, iTmp;
    register int iCurrPixel, iCurrAreaNumb, iCurrModeNumb;
    register TAreaInfo * __restrict pSrcObj, * __restrict pDstObj, * __restrict pTmpObj;

    //Проверка корректности входных параметров
    if ((Image==0)||(Width<=0)||(Height<=0)||(ModeNumb4Pix==0)||(AreasNumbBuf==0)) return -1;
    //Формирование таблицы мод пикселей
    for (i=0; i<256; i++)
    {
        if (i<Thr1)
            ModeNumb4Pix[i]=0;
        else if (i>=Thr2)
            ModeNumb4Pix[i]=1;
        else
            ModeNumb4Pix[i]=-1;
    }
    //Обнуление счётчиков кол-ва областей
    iAreasCount=iAreasInfoCount=0;
    //Обработка верхней левой точки изображения
    iCurrPixel=Image[0][0];
    iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
    if (iCurrModeNumb<0)
    {
        //Сканирование зигзагом окрестных точек для
        //выявления ближайшей с установленной модой
        iDelta=min(Width,Height);
        for (i=1; i<iDelta; i++)
        {
            iSrcIndex=-1;
            for (y=i, x=0; y>=0; y--, x++)
            {
                iDstIndex=Image[y][x];
                iTmp=ModeNumb4Pix[iDstIndex];
                if (iTmp<0) continue;
                iDstIndex=abs(iDstIndex-iCurrPixel);
                if ((iSrcIndex<0)||(iSrcIndex>iDstIndex))
                {
                    iSrcIndex=iDstIndex;
                    iCurrModeNumb=iTmp;
                }
            }
            //Нашли подходящую точку - выход из поиска
            if (iCurrModeNumb>=0) break;
        }
        //Если точек нет, то нулевая мода
        if (iCurrModeNumb<0) iCurrModeNumb=0;
    }
    iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
    AreasNumbBuf[0][0]=iCurrAreaNumb;
    //Обработка первой верхней строки изображения,
    //начиная со второго пиксела строки
    for (x=1; x<Width; x++)
    {
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Номер моды текущей точки
        iCurrModeNumb=ModeNumb4Pix[Image[0][x]];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            iCurrModeNumb=iPrevModeNumbL;
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else if (iCurrModeNumb==iPrevModeNumbL) {
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области текущей точки
        AreasNumbBuf[0][x] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }
    //Декремент ширины изображения для увеличения скорости обработки
    Width--;
    //Цикл по всем точкам изображения
    for (y=1; y<Height; y++)
    {
        //Установка начального значения для верхней левой точки
        iPrevAreaNumbUL=AreasNumbBuf[y-1][0];
        iPrevModeNumbUL=AreasInfo[iPrevAreaNumbUL].iMode;
        //Установка начального значения для верхней точки
        iPrevAreaNumbU=AreasNumbBuf[y-1][1];
        iPrevModeNumbU=AreasInfo[iPrevAreaNumbU].iMode;
        //Значение яркости первого пикселя строки
        iCurrPixel=Image[y][0];
        //Значение моды первого пикселя строки
        iPrevModeNumbL=ModeNumb4Pix[iCurrPixel];
        //В зависимости от признака переходности пиксела
        if (iPrevModeNumbL<0) {
            if (abs(iCurrPixel-Image[y-1][0])<abs(iCurrPixel-Image[y-1][1]))
            {
                iPrevModeNumbL=iPrevModeNumbUL;
                iPrevAreaNumbL=iPrevAreaNumbUL;
            }
            else
            {
                iPrevModeNumbL=iPrevModeNumbU;
                iPrevAreaNumbL=iPrevAreaNumbU;
            }
        }
        else if (iPrevModeNumbL==iPrevModeNumbUL)
            iPrevAreaNumbL=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iPrevModeNumbL==iPrevModeNumbU)
            iPrevAreaNumbL=iPrevAreaNumbU;  //Верхняя точка
        else {
            //Добавление новой области
            iPrevAreaNumbL=AddNewAreaInfo(iPrevModeNumbL);
        }
        //Установка номера области первого пиксела строки
        AreasNumbBuf[y][0] = iPrevAreaNumbL;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iPrevAreaNumbL].iCount++;
        //Обработка очередной строки изображения
        for (x=1; x<Width; x++)
        {
            //Определение параметров верхней правой точки
            iPrevAreaNumbUR=AreasNumbBuf[y-1][x+1];
            iPrevModeNumbUR=AreasInfo[iPrevAreaNumbUR].iMode;
            //Значение яркости текущего пикселя
            iCurrPixel=Image[y][x];
            //Номер моды текущей точки
            iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
            //В зависимости от того является ли точка переходной
            if (iCurrModeNumb<0)
            {
                //Текущая точка является переходной к любой области
                //Перебор всех точек окрестности и выбор наиболее близкой области
                //Левая точка
                iDelta=abs(Image[y][x-1]-iCurrPixel);
                iCurrAreaNumb=iPrevAreaNumbL;
                iCurrModeNumb=iPrevModeNumbL;
                //Верхняя точка
                iTmp=abs(Image[y-1][x]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbU;
                    iCurrModeNumb=iPrevModeNumbU;
                }
                //Верхняя левая точка
                iTmp=abs(Image[y-1][x-1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUL;
                    iCurrModeNumb=iPrevModeNumbUL;
                }
                //Верхняя правая точка
                iTmp=abs(Image[y-1][x+1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUR;
                    iCurrModeNumb=iPrevModeNumbUR;
                }
            }
            //Эта точка не является переходной ни к одной из мод
            //Просмотр всех соседних уже размеченных ранее точек
            //для возможного определения номера области текущей точки
            else if (iCurrModeNumb==iPrevModeNumbL)
                    iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
            else if (iCurrModeNumb==iPrevModeNumbUL)
                    iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
            else if (iCurrModeNumb==iPrevModeNumbU)
                    iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя точка
            else if (iCurrModeNumb==iPrevModeNumbUR)
                    iCurrAreaNumb=iPrevAreaNumbUR; //Верхняя правая точка
            else {
                //Добавление новой области
                iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
            }
            //Установка номера области текущей точки
            AreasNumbBuf[y][x] = iCurrAreaNumb;
            //Объект области в дереве
            pSrcObj=&AreasInfo[iCurrAreaNumb];
            //Инкремент счётчика площади, занимаемой областью
            pSrcObj->iCount++;
            //Сканирование верхней правой точки для добавления её в список соседних областей
            if ((iCurrModeNumb==iPrevModeNumbUR)&&(iCurrAreaNumb!=iPrevAreaNumbUR))
            {
                //Объект области предыдущей ссылки
                pDstObj=&AreasInfo[iPrevAreaNumbUR];
                //Всего четыре возможных варианта
                if (pSrcObj->iNumber<0)
                {
                    if (pDstObj->iNumber>=0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        pSrcObj->iNumber=pDstObj->iNumber;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        //Обе области являются доменными
                        iTmp=min(iCurrAreaNumb,iPrevAreaNumbUR);
                        pSrcObj->iNumber=iTmp;
                        pDstObj->iNumber=iTmp;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                }
                else //if (pSrcObj->iNumber>=0)
                {
                    if (pDstObj->iNumber<0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        pDstObj->iNumber=pSrcObj->iNumber;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        iSrcIndex=pSrcObj->iNumber;
                        iDstIndex=pDstObj->iNumber;
                        if (iSrcIndex!=iDstIndex)
                        {
                            //Это самый трудоёмкий случай.
                            //Но, к счастью, самый редкий!
                            //Необходимо объединить две области
                            for (i=0; i<iAreasInfoCount; i++)
                            {
                                pTmpObj=&AreasInfo[i];
                                if (pTmpObj->iNumber==iSrcIndex)
                                    pTmpObj->iNumber=iDstIndex;
                            }
                            //Декремент кол-ва областей
                            iAreasCount--;
                        }
                    }
                }
            }
            //Запоминание номера области и моды для левой точки
            iPrevAreaNumbL=iCurrAreaNumb;
            iPrevModeNumbL=iCurrModeNumb;
            //Запоминание номера области и моды для верхней левой точки
            iPrevAreaNumbUL=iPrevAreaNumbU;
            iPrevModeNumbUL=iPrevModeNumbU;
            //Запоминание номера области и моды для верхней точки
            iPrevAreaNumbU=iPrevAreaNumbUR;
            iPrevModeNumbU=iPrevModeNumbUR;
        }
        //Значение яркости последнего пикселя строки
        iCurrPixel=Image[y][Width];
        //Значение моды последнего пикселя строки
        iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            //Левая точка
            iDelta=abs(Image[y][x-1]-iCurrPixel);
            iCurrAreaNumb=iPrevAreaNumbL;
            iCurrModeNumb=iPrevModeNumbL;
            //Верхняя левая точка
            iTmp=abs(Image[y-1][x-1]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbUL;
                iCurrModeNumb=iPrevModeNumbUL;
            }
            //Верхняя точка
            iTmp=abs(Image[y-1][x]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbU;
                iCurrModeNumb=iPrevModeNumbU;
            }
        }
        else if (iCurrModeNumb==iPrevModeNumbL)
            iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
        else if (iCurrModeNumb==iPrevModeNumbUL)
            iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iCurrModeNumb==iPrevModeNumbU)
            iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя правая точка
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области последнего пикселя строки
        AreasNumbBuf[y][Width] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }
    //Восстановление исходной ширины изображения
    Width++;

    //Упорядочивание переадресации областей (именно здесь)!!!!!
    for (i=0; i<iAreasInfoCount; i++)
    {
        pTmpObj=&AreasInfo[i];
        iTmp=pTmpObj->iNumber;
        if (iTmp<0)
        {
            //Это независимый кластер
            pTmpObj->iNumber=i;
        }
        else if (iTmp!=i)
        {
            //Это не кластерная область
            AreasInfo[iTmp].iCount+=pTmpObj->iCount;
            //Обнуление счётчика - выключение области
            pTmpObj->iCount=0;
        }
    }

    //Могут оставаться независимые области с индексами больше iAreasCount
    for (iDstIndex=0, iSrcIndex=iAreasCount; iSrcIndex<iAreasInfoCount; iSrcIndex++)
    {
        //Если эта область уже переадресована - все нормально
        pSrcObj=&AreasInfo[iSrcIndex];
        if ((pSrcObj==NULL)||(pSrcObj->iCount==0)) continue;
        //Поиск индекса для переадресации
        for (; iDstIndex<iAreasCount; iDstIndex++)
        {
            pDstObj=&AreasInfo[iDstIndex];
            if ((pDstObj!=NULL)&&(pDstObj->iCount==0)) break;
        }
        //Сохранение указателя на моду
        pDstObj->iMode=pSrcObj->iMode;
        //Коррекция счётчиков мощности областей
        pDstObj->iCount=pSrcObj->iCount;
        pSrcObj->iCount=0;
        //Установка ссылки данной области на переадресованную
        pSrcObj->iNumber=iDstIndex;
        //Замена всех ссылок на эту область!!!!!!!!
        for (i=0; i<iAreasInfoCount; i++)
        {
            pTmpObj=&AreasInfo[i];
            if (pTmpObj->iNumber==iSrcIndex) pTmpObj->iNumber=iDstIndex;
        }
    }

    //Переписывание индексов областей на новые переназначенные
    for (y=0; y<Height; y++) for (x=0; x<Width; x++)
    {
        iTmp=AreasNumbBuf[y][x];
        iTmp=AreasInfo[iTmp].iNumber;
        AreasNumbBuf[y][x]=iTmp;
    }

    return iAreasCount;
}

void calcModes(unsigned char * restrict image, char * restrict modes, int pixelsCount, int thresold1, int thresold2)
{  
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    for(int i=0;i<pixelsCount;i+=8)
    {
        // Загрузим сразу 8 пикселов
        double pixels=_amemd8_const(image+i);                       // D

        // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
        int compare1Lo=_xpnd4(_cmpgtu4(_lo(pixels),thresoldLo));    // L + M

        // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
        int compare1Hi=_xpnd4(_cmpgtu4(_lo(pixels),thresoldHi));    // L + M

        // Здесь очень удачно все сложилось - возможны три варианта:
        // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
        // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
        // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
        int result1=compare1Lo ^ (compare1Hi & 0xfefefefe);         // LSD + LSD


        // Здесь все тоже самое, для оставшихся четырех пикселов
        int compare2Lo=_xpnd4(_cmpgtu4(_hi(pixels),thresoldLo));    // L + M
        int compare2Hi=_xpnd4(_cmpgtu4(_hi(pixels),thresoldHi));    // L + M

        int result2=compare2Lo ^ (compare2Hi & 0xfefefefe);         // LSD + LSD

        // Сохраним результат
        _amemd8(image+i)=_itod(result2,result1);                    // D

        // Здесь получаем, что 4L и 4M юнита - два цикла; еще осталось 4S и 4D, 2D на загрузку
        // уйдет -> остается 4S и 2D юнита, для внутренностей цикла надо 4LSD => останется два S
        // юнита на поддержание цикла. Теоретически, производительность кода - 2 такта на 8 пикселов
        // или 0.25 такта на пиксел. При этом удалось добиться соответствия со значениями мод из
        // оригинального кода, добавив лишь одно ограничение по - количество пикселей должно быть кратно 8.
        // Следует также отметить, что даже при больших размерах изображения, не возникает простоя из-за
        // того, что данные не находятся в кэше.
    }
}

    //Обработка первой верхней строки изображения, начиная со второго пиксела строки
    for (x=1; x<Width; x++)
    {
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Номер моды текущей точки
        iCurrModeNumb=ModeNumb4Pix[Image[0][x]];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            iCurrModeNumb=iPrevModeNumbL;
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else if (iCurrModeNumb==iPrevModeNumbL) {
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области текущей точки
        AreasNumbBuf[0][x] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }

#include <stdlib.h>
#include <csl_dat.h>

#define IMG_WIDTH  640
#define IMG_HEIGHT 480

// Буферы для кэширования строк изображения
static unsigned char ModesBuf[3][IMG_WIDTH];

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int thresold1, int thresold2)
{
    //Рабочие регистры цикла
    int lockPixels, compareLo, compareHi, result1, result2;
    unsigned char * restrict pCurrLineBuf;
    double pixels;

    //Open DAT-chanel
    DAT_open(DAT_CHAANY, DAT_PRI_HIGH, 0);

    //Загрузка первой строки изображения
    Uint32 id_LoadTransfer = DAT_copy(image[0], ModesBuf[0], IMG_WIDTH);
    //Начальная инициализация идентификатора канала сохранения
    Uint32 id_SaveTransfer=DAT_XFRID_WAITNONE;

    //кольцевой указатель на буфер текущей строки
    int iCurrBufIndex=0;

    //пакеты порогов
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    //цикл по всем строкам изображения
//#pragma MUST_ITERATE(IMG_HEIGHT, IMG_HEIGHT);
    for(int y=0; y<IMG_HEIGHT; y++)
    {
        //Указатель на текущую обрабатываемую строку
        pCurrLineBuf = ModesBuf[iCurrBufIndex];
        //Продвижение индекса на следующую строку
        iCurrBufIndex++; iCurrBufIndex%=3;
        //Ожидание окончания загрузки текущей строки изображения
        while(DAT_busy(id_LoadTransfer));
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer = DAT_copy(image[y+1], ModesBuf[iCurrBufIndex], IMG_WIDTH);
        //обработка текущей строки
//#pragma MUST_ITERATE(IMG_WIDTH/8, IMG_WIDTH/8);
        for(int x=0; x<IMG_WIDTH; x+=8)
        {
            // Загрузим сразу 8 пикселов
            pixels=_amemd8_const(pCurrLineBuf+x);                  // D

            //Первые четыре пиксела
            lockPixels=_lo(pixels);

            // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M

            // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            // Здесь очень удачно все сложилось - возможны три варианта:
            // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
            // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
            // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
            result1=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Здесь все тоже самое, для оставшихся четырех пикселов
            lockPixels=_hi(pixels);

            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            result2=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Сохраним результат
            _amemd8(pCurrLineBuf+x)=_itod(result2,result1);        // D

            // Здесь получаем, что 4L и 4M юнита - два цикла; еще осталось 4S и 4D, 2D на загрузку
            // уйдет -> остается 4S и 2D юнита, для внутренностей цикла надо 4LSD => останется два S
            // юнита на поддержание цикла. Теоретически, производительность кода - 2 такта на 8 пикселов
            // или 0.25 такта на пиксел. При этом удалось добиться соответствия со значениями мод из
            // оригинального кода, добавив лишь одно ограничение по - количество пикселей должно быть кратно 8.
            // Следует также отметить, что даже при больших размерах изображения, не возникает простоя из-за
            // того, что данные не находятся в кэше.
        }
        //Ожидание окончания сохранения результата
        while(DAT_busy(id_SaveTransfer));
        //Сохранение строки результата
        id_SaveTransfer = DAT_copy(pCurrLineBuf, modes[y], IMG_WIDTH);
    }

    //Ожидание окончания сохранения результата
    while(DAT_busy(id_SaveTransfer));

    //Close DAT-chanel
    DAT_close();
}

#include <stdlib.h>

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int height, int width, int thresold1, int thresold2)
{
    if ((image==NULL)||(modes==NULL)) return;

    //цикл по всем пикселам изображения
    for(int y=0; y<height; y++) for(int x=0; x<width; x++)
    {
        int pixel=image[y][x];
        if (pixel<thresold1)
            modes[y][x]=0;
        else if (pixel>thresold2)
            modes[y][x]=1;
        else
            modes[y][x]=-1;
    }
}

#include <stdlib.h>

#include "cs_common.h"

// Буферы для кэширования строк изображения
static unsigned char ModesBuf[3][IMG_WIDTH];

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int thresold1, int thresold2)
{
    //Рабочие регистры цикла
    int lockPixels, compareLo, compareHi, result1, result2;
    unsigned char * restrict pCurrLineBuf;
    double pixels;

    //кольцевой указатель на буфер текущей строки
    int iCurrBufIndex=0;

    //пакеты порогов
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    //цикл по всем строкам изображения
//#pragma MUST_ITERATE(IMG_HEIGHT, IMG_HEIGHT);
    for(int y=0; y<IMG_HEIGHT; y++)
    {
        //Указатель на текущую обрабатываемую строку
        pCurrLineBuf = ModesBuf[iCurrBufIndex];
        //Продвижение индекса на следующую строку
        iCurrBufIndex++; iCurrBufIndex%=3;
        //обработка текущей строки
//#pragma MUST_ITERATE(IMG_WIDTH/8, IMG_WIDTH/8);
        for(int x=0; x<IMG_WIDTH; x+=8)
        {
            // Загрузим сразу 8 пикселов
            pixels=_amemd8_const(pCurrLineBuf+x);                  // D

            //Первые четыре пиксела
            lockPixels=_lo(pixels);

            // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M

            // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            // Здесь очень удачно все сложилось - возможны три варианта:
            // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
            // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
            // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
            result1=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Здесь все тоже самое, для оставшихся четырех пикселов
            lockPixels=_hi(pixels);

            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            result2=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Сохраним результат
            _amemd8(pCurrLineBuf+x)=_itod(result2,result1);        // D
        }
    }
}

..11..22..
...11.2...
....11....

#include <stdlib.h>
#include <string.h>
#include <csl_dat.h>

//Максимальное кол-во областей в изображении
#define MAX_AREAS 1000
//Максимальная ширина изображения
#define IMG_WIDTH_MAX  640
//Максимальная высота изображения
#define IMG_HEIGHT_MAX 480
//Макросы минимума и максимума
#define max(a, b)  (((a) > (b)) ? (a) : (b))
#define min(a, b)  (((a) < (b)) ? (a) : (b))


//Счётчики количества областей в изображении и в контейнере
static int iAreasCount=0, iAreasInfoCount=0;

//Ограниченные массивы структур описателей областей!!!
static short AreasMode[MAX_AREAS+1];
static short AreasNumber[MAX_AREAS+1];

//Функция создания новой области
static inline int AddNewAreaInfo(const int iModeNumb)
{
//    if (iAreasInfoCount>=MAX_AREAS) return -1;
    iAreasCount++;
    AreasMode[iAreasInfoCount]=iModeNumb;
    AreasNumber[iAreasInfoCount]=-1;
    return iAreasInfoCount++;
}

// Буферы для кэширования строк изображения
static unsigned char ImageBuf[3][IMG_WIDTH_MAX];
static int AreasBuf[2][IMG_WIDTH_MAX];


int test_SplitImage2Areas(
    register unsigned char ** restrict Image,
    register int Height, register int Width,
    register short * restrict ModeNumb4Pix,
    register int ** restrict Areas)
{
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    //Вычисление площади, занимаемой каждой областью и модой
    register int iPrevAreaNumbL=-1;  //Номер области предыдущей левой точки
    register int iPrevModeNumbL=-1;  //Номер моды предыдущей левой точки
    register int iPrevAreaNumbU=-1;  //Номер области предыдущей верхней точки
    register int iPrevModeNumbU=-1;  //Номер моды предыдущей верхней точки
    register int iPrevAreaNumbUL=-1; //Номер области предыдущей верхней левой точки
    register int iPrevModeNumbUL=-1; //Номер моды предыдущей верхней левой точки
    register int iPrevAreaNumbUR=-1; //Номер области предыдущей верхней правой точки
    register int iPrevModeNumbUR=-1; //Номер моды предыдущей верхней правой точки
    //Временные переменные
    register int i, y, x, iSrcIndex, iDstIndex, iDelta, iTmp;
    register int iCurrPixel, iCurrAreaNumb, iCurrModeNumb;
    register Uint32 id_LoadTransfer, id_SaveTransfer;
    register int iImageBufIndex, iAreasBufIndex;
    register unsigned char * restrict pImageCurrBuf;
    register unsigned char * restrict pImagePrevBuf;
    register int * restrict pAreasCurrBuf;
    register int * restrict pAreasPrevBuf;

    //Проверка корректности входных параметров
    if ((Image==0)||(ModeNumb4Pix==0)||(Areas==0)) return -1;
    if ((Width<=0)||(Height<=0)||(Width>IMG_WIDTH_MAX)||(Height>IMG_HEIGHT_MAX)) return -1;

    //Загрузка первой строки изображения
    id_LoadTransfer=DAT_copy(Image[0], ImageBuf[0], Width);

    //Обнуление счётчиков кол-ва областей
    iAreasCount=iAreasInfoCount=0;
    //Обработка верхней левой точки изображения
    iCurrPixel=Image[0][0];
    iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
    if (iCurrModeNumb<0)
    {
        //Сканирование зигзагом окрестных точек для
        //выявления ближайшей с установленной модой
        iDelta=min(Width,Height);
        for (i=1; i<iDelta; i++)
        {
            iSrcIndex=-1;
            for (y=i, x=0; y>=0; y--, x++)
            {
                iDstIndex=Image[y][x];
                iTmp=ModeNumb4Pix[iDstIndex];
                if (iTmp<0) continue;
                iDstIndex=abs(iDstIndex-iCurrPixel);
                if ((iSrcIndex<0)||(iSrcIndex>iDstIndex))
                {
                    iSrcIndex=iDstIndex;
                    iCurrModeNumb=iTmp;
                }
            }
            //Нашли подходящую точку - выход из поиска
            if (iCurrModeNumb>=0) break;
        }
        //Если точек нет, то нулевая мода
        if (iCurrModeNumb<0) iCurrModeNumb=0;
    }
    iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
    AreasBuf[0][0]=iCurrAreaNumb;
    //Указатель на текущую обрабатываемую строку изображения
    pImageCurrBuf=ImageBuf[0];
    //Указатель на текущую результирующую строку номеров областей
    pAreasCurrBuf=AreasBuf[0];
    //Ожидание окончания загрузки первой строки изображения
    while(DAT_busy(id_LoadTransfer));
    //Запуск загрузки второй строки изображения
    id_LoadTransfer=DAT_copy(Image[1], ImageBuf[1], Width);
    //Обработка первой верхней строки изображения,
    //начиная со второго пиксела строки
    for (x=1; x<Width; x++)
    {
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Номер моды текущей точки
        iCurrModeNumb=ModeNumb4Pix[pImageCurrBuf[x]];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            iCurrModeNumb=iPrevModeNumbL;
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else if (iCurrModeNumb==iPrevModeNumbL) {
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области текущей точки
        pAreasCurrBuf[x]=iCurrAreaNumb;
    }
    //Сохранение первой строки результата
    id_SaveTransfer=DAT_copy(AreasBuf[0], Areas[0], Width);
    //установка кольцевого указателя на буфер текущей строки
    iImageBufIndex=iAreasBufIndex=1;
    //Декремент ширины изображения для увеличения скорости обработки
    Width--;
    //Цикл по всем точкам изображения
    for (y=1; y<Height; y++)
    {
        //Сохранение указателя на предыдущую строку изображения
        pImagePrevBuf=pImageCurrBuf;
        //Сохранение указателя на предыдущую строку результата
        pAreasPrevBuf=pAreasCurrBuf;
        //Указатель на текущую строку изображения
        pImageCurrBuf=ImageBuf[iImageBufIndex];
        //Указатель на текущую строку результата
        pAreasCurrBuf=AreasBuf[iAreasBufIndex];
        //Продвижение индекса на следующую строку
        iImageBufIndex++; iImageBufIndex%=3;
        iAreasBufIndex++; iAreasBufIndex%=2;
        //Ожидание окончания загрузки текущей строки изображения
        while(DAT_busy(id_LoadTransfer));
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer = DAT_copy(Image[y+1], ImageBuf[iImageBufIndex], Width);
        //Установка начального значения для верхней левой точки
        iPrevAreaNumbUL=pAreasPrevBuf[0];
        iPrevModeNumbUL=AreasMode[iPrevAreaNumbUL];
        //Установка начального значения для верхней точки
        iPrevAreaNumbU=pAreasPrevBuf[1];
        iPrevModeNumbU=AreasMode[iPrevAreaNumbU];
        //Значение яркости первого пикселя строки
        iCurrPixel=pImageCurrBuf[0];
        //Значение моды первого пикселя строки
        iPrevModeNumbL=ModeNumb4Pix[iCurrPixel];
        //В зависимости от признака переходности пиксела
        if (iPrevModeNumbL<0) {
            if (abs(iCurrPixel-pImagePrevBuf[0])<abs(iCurrPixel-pImagePrevBuf[1]))
            {
                iPrevModeNumbL=iPrevModeNumbUL;
                iPrevAreaNumbL=iPrevAreaNumbUL;
            }
            else
            {
                iPrevModeNumbL=iPrevModeNumbU;
                iPrevAreaNumbL=iPrevAreaNumbU;
            }
        }
        else if (iPrevModeNumbL==iPrevModeNumbUL)
            iPrevAreaNumbL=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iPrevModeNumbL==iPrevModeNumbU)
            iPrevAreaNumbL=iPrevAreaNumbU;  //Верхняя точка
        else {
            //Добавление новой области
            iPrevAreaNumbL=AddNewAreaInfo(iPrevModeNumbL);
        }
        //Установка номера области первого пиксела строки
        pAreasCurrBuf[0] = iPrevAreaNumbL;
        //Обработка очередной строки изображения
        for (x=1; x<Width; x++)
        {
            //Определение параметров верхней правой точки
            iPrevAreaNumbUR=pAreasPrevBuf[x+1];
            iPrevModeNumbUR=AreasMode[iPrevAreaNumbUR];
            //Значение яркости текущего пикселя
            iCurrPixel=pImageCurrBuf[x];
            //Номер моды текущей точки
            iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
            //В зависимости от того является ли точка переходной
            if (iCurrModeNumb<0)
            {
                //Текущая точка является переходной к любой области
                //Перебор всех точек окрестности и выбор наиболее близкой области
                //Левая точка
                iDelta=abs(pImageCurrBuf[x-1]-iCurrPixel);
                iCurrAreaNumb=iPrevAreaNumbL;
                iCurrModeNumb=iPrevModeNumbL;
                //Верхняя точка
                iTmp=abs(pImagePrevBuf[x]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbU;
                    iCurrModeNumb=iPrevModeNumbU;
                }
                //Верхняя левая точка
                iTmp=abs(pImagePrevBuf[x-1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUL;
                    iCurrModeNumb=iPrevModeNumbUL;
                }
                //Верхняя правая точка
                iTmp=abs(pImagePrevBuf[x+1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUR;
                    iCurrModeNumb=iPrevModeNumbUR;
                }
            }
            //Эта точка не является переходной ни к одной из мод
            //Просмотр всех соседних уже размеченных ранее точек
            //для возможного определения номера области текущей точки
            else if (iCurrModeNumb==iPrevModeNumbL)
                    iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
            else if (iCurrModeNumb==iPrevModeNumbUL)
                    iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
            else if (iCurrModeNumb==iPrevModeNumbU)
                    iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя точка
            else if (iCurrModeNumb==iPrevModeNumbUR)
                    iCurrAreaNumb=iPrevAreaNumbUR; //Верхняя правая точка
            else {
                //Добавление новой области
                iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
            }
            //Установка номера области текущей точки
            pAreasCurrBuf[x] = iCurrAreaNumb;
            //Сканирование верхней правой точки для добавления её в список соседних областей
            if ((iCurrModeNumb==iPrevModeNumbUR)&&(iCurrAreaNumb!=iPrevAreaNumbUR))
            {
                //Всего четыре возможных варианта
                if (AreasNumber[iCurrAreaNumb]<0)
                {
                    if (AreasNumber[iPrevAreaNumbUR]>=0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        AreasNumber[iCurrAreaNumb]=AreasNumber[iPrevAreaNumbUR];
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        //Обе области являются доменными
                        iTmp=min(iCurrAreaNumb,iPrevAreaNumbUR);
                        AreasNumber[iCurrAreaNumb]=iTmp;
                        AreasNumber[iPrevAreaNumbUR]=iTmp;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                }
                else //if (AreasNumber[iCurrAreaNumb]>=0)
                {
                    if (AreasNumber[iPrevAreaNumbUR]<0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        AreasNumber[iPrevAreaNumbUR]=AreasNumber[iCurrAreaNumb];
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        iSrcIndex=AreasNumber[iCurrAreaNumb];
                        iDstIndex=AreasNumber[iPrevAreaNumbUR];
                        if (iSrcIndex!=iDstIndex)
                        {
                            //Это самый трудоёмкий случай.
                            //Но, к счастью, самый редкий!
                            //Необходимо объединить две области
                            if (iSrcIndex<iDstIndex)
                            {
                                //Обмен значениями
                                iTmp=iSrcIndex;
                                iSrcIndex=iDstIndex;
                                iDstIndex=iTmp;
                            }
                            for (i=0; i<iAreasInfoCount; i++)
                            {
                                if (AreasNumber[i]==iSrcIndex)
                                    AreasNumber[i]=iDstIndex;
                            }
                            //Декремент кол-ва областей
                            iAreasCount--;
                        }
                    }
                }
            }
            //Запоминание номера области и моды для левой точки
            iPrevAreaNumbL=iCurrAreaNumb;
            iPrevModeNumbL=iCurrModeNumb;
            //Запоминание номера области и моды для верхней левой точки
            iPrevAreaNumbUL=iPrevAreaNumbU;
            iPrevModeNumbUL=iPrevModeNumbU;
            //Запоминание номера области и моды для верхней точки
            iPrevAreaNumbU=iPrevAreaNumbUR;
            iPrevModeNumbU=iPrevModeNumbUR;
        }
        //Значение яркости последнего пикселя строки
        iCurrPixel=pImageCurrBuf[Width];
        //Значение моды последнего пикселя строки
        iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            //Левая точка
            iDelta=abs(pImageCurrBuf[x-1]-iCurrPixel);
            iCurrAreaNumb=iPrevAreaNumbL;
            iCurrModeNumb=iPrevModeNumbL;
            //Верхняя левая точка
            iTmp=abs(pImagePrevBuf[x-1]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbUL;
                iCurrModeNumb=iPrevModeNumbUL;
            }
            //Верхняя точка
            iTmp=abs(pImagePrevBuf[x]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbU;
                iCurrModeNumb=iPrevModeNumbU;
            }
        }
        else if (iCurrModeNumb==iPrevModeNumbL)
            iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
        else if (iCurrModeNumb==iPrevModeNumbUL)
            iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iCurrModeNumb==iPrevModeNumbU)
            iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя правая точка
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области последнего пикселя строки
        pAreasCurrBuf[Width]=iCurrAreaNumb;
        //Ожидание окончания сохранения результата
        while(DAT_busy(id_SaveTransfer));
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasCurrBuf, Areas[y], Width);
    }
    //Восстановление исходной ширины изображения
    Width++;

    //Упорядочивание переадресации областей (именно здесь)!!!!!
    for (i=0; i<iAreasInfoCount; i++)
    {
        //Номер кластера для текущей области
        iTmp=AreasNumber[i];
        //Пропуск кластерных областей
        if (iTmp<0)
            //Установка номера области
            AreasNumber[i]=i;
        else
            //Выключение области
            AreasMode[i]=-1;
    }

    //Могут оставаться независимые области с индексами больше iAreasCount
    for (iDstIndex=0, iSrcIndex=iAreasCount; iSrcIndex<iAreasInfoCount; iSrcIndex++)
    {
        //Если эта область уже переадресована - все нормально
        if (AreasMode[iSrcIndex]<0) continue;
        //Поиск индекса для переадресации
        for (/*задаётся вовне*/; iDstIndex<iAreasCount; iDstIndex++)
            if (AreasMode[iDstIndex]<0) break;
        //Сохранение указателя на моду
        AreasMode[iDstIndex]=AreasMode[iSrcIndex];
        //Выключение переадресуемой области
        AreasMode[iSrcIndex]=-1;
        //Установка ссылки данной области на переадресованную
        AreasNumber[iSrcIndex]=iDstIndex;
        //Замена всех ссылок на эту область!!!!!!!!
        for (i=0; i<iAreasInfoCount; i++)
            if (AreasNumber[i]==iSrcIndex) AreasNumber[i]=iDstIndex;
    }

    //Загрузка первой строки номеров областей
    id_LoadTransfer=DAT_copy(Areas[0], AreasBuf[0], Width);
    //Установка кольцевого указателя
    iAreasBufIndex=0;
    //Начальная инициализация идентификатора канала сохранения
    id_SaveTransfer=DAT_XFRID_WAITNONE;
    //Обработка всех строк
    for (y=0; y<Height; y++)
    {
        //Указатель на текущую строку результата
        pAreasCurrBuf=AreasBuf[iAreasBufIndex];
        //Продвижение индекса на следующую строку
        iAreasBufIndex^=1;
        //Ожидание окончания загрузки текущей строки изображения
        while(DAT_busy(id_LoadTransfer));
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer=DAT_copy(Areas[y+1], AreasBuf[iAreasBufIndex], Width);
        //Переписывание индексов удалённых областей на переназначенные
        for (x=0; x<Width; x++) pAreasCurrBuf[x]=AreasNumber[pAreasCurrBuf[x]];
        //Ожидание окончания сохранения результата
        while(DAT_busy(id_SaveTransfer));
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasCurrBuf, Areas[y], Width);
    }
    //Ожидание окончания сохранения результата
    while(DAT_busy(id_SaveTransfer));

    return iAreasCount;
}

#include <stdlib.h>
#include <limits.h>
#include <csl_dat.h>

//Максимальное кол-во областей в изображении
#define MAX_AREAS 2000

//Ограниченный массив структур описателей областей!!!
#pragma DATA_ALIGN(8);
static short AreasMode[MAX_AREAS+1];
#pragma DATA_ALIGN(8);
static short AreasNumber[MAX_AREAS+1];
#pragma DATA_ALIGN(8);
static short AreasPixel[MAX_AREAS+1];

//Буферы для кэширования строк изображения
#pragma DATA_ALIGN(8);
static unsigned char ImageBuf[2][IMG_WIDTH_MAX];
#pragma DATA_ALIGN(8);
static unsigned short AreasBuf[2][IMG_WIDTH_MAX];


int dsp_SplitImage2AreasFast(
    unsigned char ** restrict Image,
    int Height, int Width,
    unsigned char *  restrict ModeNumb4Pix,
    unsigned short ** restrict Areas)
{
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    //Вычисление площади, занимаемой каждой областью и модой
    register int iAreasCounter;    //Счётчик количества областей в изображении
    register int iAreasInfoCounter;//Счётчик количества областей в контейнере
    register int iPrevAreaNumbL;   //Номер области предыдущей левой точки
    register int iPrevModeNumbL;   //Номер моды предыдущей левой точки
    //Временные переменные
    register int i, y, x, iSrcIndex, iDstIndex, iTmp;
    register int iCurrAreaNumb, iCurrModeNumb, iAreasInfoCountSav;
    register Uint32 id_LoadTransfer, id_SaveTransfer;
    register unsigned char * restrict pImageNextBuf;
    register unsigned char * restrict pImageCurrBuf;
    register unsigned short * restrict pAreasCurrBuf;
    register unsigned short * restrict pAreasPrevBuf;

    //Проверка корректности входных параметров
    if ((Image==0)||(ModeNumb4Pix==0)||(Areas==0)||(Width<=0)||(Height<=0)||
        (Width>IMG_WIDTH_MAX)||(Height>IMG_HEIGHT_MAX)) return -1;

    //Установка указателя на следующую строку изображения
    pImageNextBuf=ImageBuf[0];
    //Загрузка первой строки изображения
    id_LoadTransfer=DAT_copy(Image[0], pImageNextBuf, Width);
    //Начальная инициализация идентификатора канала сохранения
    id_SaveTransfer=DAT_XFRID_WAITNONE;

    //Обнуление счётчиков кол-ва областей
    iAreasCounter=iAreasInfoCounter=0;
    //Установка кол-ва областей максимально возможное для первой строки
    iAreasInfoCountSav=INT_MAX;
    //Обнуление указателя на текущую строку
    pAreasCurrBuf=NULL;
    //Цикл по всем точкам изображения
    for (y=0; y<Height; y++)
    {
        //Сохранение указателя на текущую строку изображения
        pImageCurrBuf=pImageNextBuf;
        //Сохранение указателя на предыдущую строку результата
        pAreasPrevBuf=pAreasCurrBuf;
        //Указатель на следующую строку изображения
        pImageNextBuf=ImageBuf[(y+1)&1];
        //Указатель на текущую строку результата
        pAreasCurrBuf=AreasBuf[y&1];
        //Начальные значения номера области и моды для левой точки
        iPrevModeNumbL=iPrevAreaNumbL=-1;
        //Ожидание окончания загрузки текущей строки изображения
        DAT_wait(id_LoadTransfer);
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer = DAT_copy(Image[y+1], pImageNextBuf, Width);
        //Обработка очередной строки изображения
        for (x=0; x<Width; x++)
        {
            //Номер моды текущей точки
            iCurrModeNumb=ModeNumb4Pix[pImageCurrBuf[x]];
            //В зависимости от того принадлежит ли точка той же моде,
            //что и её левая точка, установка номера области
            if (iCurrModeNumb==iPrevModeNumbL)
                iCurrAreaNumb=iPrevAreaNumbL;
            else
            {
                //Добавление новой области
//                if (iAreasInfoCount>=MAX_AREAS) return -1;
                iCurrAreaNumb=iAreasInfoCounter;
                AreasMode[iAreasInfoCounter]=iCurrModeNumb;
                AreasNumber[iAreasInfoCounter]=iAreasInfoCounter;
                AreasPixel[iAreasInfoCounter]=x;
                //Инкремент счётчиков областей
                iAreasCounter++; iAreasInfoCounter++;
                //Запоминание номера области и моды для левой точки
                iPrevAreaNumbL=iCurrAreaNumb;
                iPrevModeNumbL=iCurrModeNumb;
            }
            //Установка номера области текущей точки
            pAreasCurrBuf[x]=iCurrAreaNumb;
        }
        //Обработка всех областей в текущей строке для выявления их связей
        //с областями на предыдущей строке
        for (; iAreasInfoCountSav<iAreasInfoCounter; iAreasInfoCountSav++)
        {
            iSrcIndex=iAreasInfoCountSav;
            iCurrModeNumb=AreasMode[iAreasInfoCountSav];
            iTmp=AreasPixel[iAreasInfoCountSav];
            if (iTmp>0) iTmp--;
            if (iAreasInfoCountSav==(iAreasInfoCounter-1))
                iCurrAreaNumb=Width-1;
            else
                iCurrAreaNumb=AreasPixel[iAreasInfoCountSav+1];
            iCurrAreaNumb=pAreasPrevBuf[iCurrAreaNumb];
            //Цикл по всем граничащим на предыдущей строке областям
            for (i=pAreasPrevBuf[iTmp]; i<=iCurrAreaNumb; i++)
            {
                if (AreasMode[i]!=iCurrModeNumb) continue;
                //На предыдущей строке найдена область с совпадающей модой,
                //которая соседствует с исходной
                iDstIndex=i;
                while(AreasNumber[iDstIndex]!=iDstIndex) iDstIndex=AreasNumber[iDstIndex];
                if (iSrcIndex!=iDstIndex)
                {
                    //Объединение двух кластеров областей
                    if (iSrcIndex<iDstIndex)
                    {
                        //Сохранение номера
                        AreasNumber[iDstIndex]=iSrcIndex;
                    }
                    else
                    {
                        //Сохранение номера
                        AreasNumber[iSrcIndex]=iDstIndex;
                        //Для дальнейшего объединения берётся меньший индекс
                        iSrcIndex=iDstIndex;
                    }
                    //Декремент кол-ва областей
                    iAreasCounter--;
                }
            }
        }
        //Сохранение кол-ва областей
        iAreasInfoCountSav=iAreasInfoCounter;
        //Ожидание окончания сохранения результата
        DAT_wait(id_SaveTransfer);
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasCurrBuf, Areas[y], sizeof(short)*Width);
    }

    //Обновление ссылок на области
    for (iSrcIndex=0; iSrcIndex<iAreasInfoCounter; iSrcIndex++)
    {
        //Поиск индекса назначения
        iDstIndex=iSrcIndex;
        while(AreasNumber[iDstIndex]!=iDstIndex) iDstIndex=AreasNumber[iDstIndex];
        //Обновление номера области
        AreasNumber[iSrcIndex]=iDstIndex;
    }

    //Могут оставаться независимые области с индексами больше iAreasCount
    for (iDstIndex=-1, iSrcIndex=iAreasCounter; iSrcIndex<iAreasInfoCounter; iSrcIndex++)
    {
        //Если эта область уже переадресована - все нормально
        if (AreasNumber[iSrcIndex]!=iSrcIndex) continue;
        //Поиск индекса для переадресации
        for (iDstIndex++; iDstIndex<iAreasCounter; iDstIndex++)
            if (AreasNumber[iDstIndex]!=iDstIndex) break;
        //Сохранение указателя на моду
        AreasMode[iDstIndex]=AreasMode[iSrcIndex];
        //Установка ссылки данной области на переадресованную
        AreasNumber[iSrcIndex]=iDstIndex;
        //Замена всех ссылок на эту область!!!!!!!!
        for (i=iSrcIndex; i<iAreasInfoCounter; i++)
            if (AreasNumber[i]==iSrcIndex) AreasNumber[i]=iDstIndex;
    }

    //Установка указателя на текущую загружаемую строку
    pAreasCurrBuf=AreasBuf[0];
    //Загрузка первой строки номеров областей
    id_LoadTransfer=DAT_copy(Areas[0], pAreasCurrBuf, sizeof(short)*Width);
    //Начальная инициализация идентификатора канала сохранения
    id_SaveTransfer=DAT_XFRID_WAITNONE;
    //Обработка всех строк
    for (y=0; y<Height; y++)
    {
        //Сохранение указателя на предыдущую строку результата
        pAreasPrevBuf=pAreasCurrBuf;
        //Указатель на следующую строку результата
        pAreasCurrBuf=AreasBuf[(y+1)&1];
        //Ожидание окончания загрузки текущей строки изображения
        DAT_wait(id_LoadTransfer);
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer=DAT_copy(Areas[y+1], pAreasCurrBuf, sizeof(short)*Width);
        //Переписывание индексов удалённых областей на переназначенные
        for (x=0; x<Width; x++) pAreasPrevBuf[x]=AreasNumber[pAreasPrevBuf[x]];
        //Ожидание окончания сохранения результата
        DAT_wait(id_SaveTransfer);
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasPrevBuf, Areas[y], sizeof(short)*Width);
    }
    //Ожидание окончания сохранения результата
    DAT_wait(id_SaveTransfer);

    return iAreasCounter;
}

/*!\brief Разбиение изображения на непересекающиеся области
* \brief в соответствии с таблицей мод
* \param Image - исходное изображение
* \param Height - высота изображения
* \param Width - ширина изображение
* \param ModeNumb4Pix - таблица соответствия значений пикселов модам гистограммы
* \param Areas - буфер результата, отражающий номера областей каждого из пикселов
* \result Количество непересекающихся областей в изображении
*/
#include <stdlib.h>
#include <csl_dat.h>

//Максимальное кол-во областей в изображении
#define MAX_AREAS 2000

//Ограниченный массив структур описателей областей!!!
#pragma DATA_ALIGN(8);
static short AreasMode[MAX_AREAS+1];
#pragma DATA_ALIGN(8);
static short AreasNumber[MAX_AREAS+1];
#pragma DATA_ALIGN(8);
static short AreasPixel[MAX_AREAS+1];

//Буферы для кэширования строк изображения
#pragma DATA_ALIGN(8);
static unsigned char ImageBuf[2][IMG_WIDTH_MAX];
#pragma DATA_ALIGN(8);
static unsigned short AreasBuf[2][IMG_WIDTH_MAX];


int dsp_SplitImage2AreasFast(
    unsigned char ** restrict Image,
    int Height, int Width,
    unsigned char *  restrict ModeNumb4Pix,
    unsigned short ** restrict Areas)
{
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    //Вычисление площади, занимаемой каждой областью и модой
    register int iAreasCounter;    //Счётчик количества областей в изображении
    register int iAreasInfoCounter;//Счётчик количества областей в контейнере
    //Временные переменные
    register int i, y, x, iSrcIndex, iDstIndex, iTmp;
    register int iCurrAreaNumb, iCurrModeNumb;
    register Uint32 id_LoadTransfer, id_SaveTransfer;
    register unsigned char * restrict pImageNextBuf;
    register unsigned char * restrict pImageCurrBuf;
    register unsigned short * restrict pAreasCurrBuf;
    register unsigned short * restrict pAreasPrevBuf;

    //Проверка корректности входных параметров
    if ((Image==0)||(ModeNumb4Pix==0)||(Areas==0)||
        (Width<=0)||(Height<=0)||(Width>IMG_WIDTH_MAX)) return -1;

    //Установка указателя на следующую строку изображения
    pImageNextBuf=ImageBuf[0];
    //Загрузка первой строки изображения
    id_LoadTransfer=DAT_copy(Image[0], pImageNextBuf, Width);
    //Начальная инициализация идентификатора канала сохранения
    id_SaveTransfer=DAT_XFRID_WAITNONE;

    //Обнуление счётчиков кол-ва областей
    iAreasCounter=iAreasInfoCounter=0;
    //Установка кол-ва областей максимально возможное для исключения
    //применения к первой строке ветви выявления связей с предыдущими строками
    iTmp=IMG_WIDTH_MAX;
    //Обнуление указателя на текущую строку
    pAreasCurrBuf=NULL;
    //Цикл по всем точкам изображения
    for (y=0; y<Height; y++)
    {
        //Сохранение указателя на текущую строку изображения
        pImageCurrBuf=pImageNextBuf;
        //Сохранение указателя на предыдущую строку результата
        pAreasPrevBuf=pAreasCurrBuf;
        //Указатель на следующую строку изображения
        pImageNextBuf=ImageBuf[(y+1)&1];
        //Указатель на текущую строку результата
        pAreasCurrBuf=AreasBuf[y&1];
        //Начальные значения номера моды
        iCurrModeNumb=-1;
        //Ожидание окончания загрузки текущей строки изображения
        DAT_wait(id_LoadTransfer);
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer = DAT_copy(Image[y+1], pImageNextBuf, Width);
        //Обработка очередной строки изображения
        for (x=0; x<Width; x++)
        {
            //Номер моды текущей точки
            i=ModeNumb4Pix[pImageCurrBuf[x]];
            //В зависимости от того принадлежит ли точка той же моде,
            //что и её левая точка, установка номера области
            if (iCurrModeNumb!=i)
            {
                //Добавление новой области
//                if (iAreasInfoCount>=MAX_AREAS) return -1;
                iCurrModeNumb=i;
                iCurrAreaNumb=iAreasInfoCounter;
                AreasMode[iAreasInfoCounter]=iCurrModeNumb;
                AreasNumber[iAreasInfoCounter]=iAreasInfoCounter;
                AreasPixel[iAreasInfoCounter]=x;
                //Инкремент счётчиков областей
                iAreasCounter++; iAreasInfoCounter++;
            }
            //Установка номера области текущей точки
            pAreasCurrBuf[x]=iCurrAreaNumb;
        }
        //Обработка всех областей в текущей строке для выявления их связей
        for (; iTmp<iAreasInfoCounter; iTmp++)
        {
            iSrcIndex=iTmp;
            iCurrModeNumb=AreasMode[iTmp];
            i=AreasPixel[iTmp];
            if (i>0) i--;
            if (iTmp==(iAreasInfoCounter-1))
                iCurrAreaNumb=Width-1;
            else
                iCurrAreaNumb=AreasPixel[iTmp+1];
            iCurrAreaNumb=pAreasPrevBuf[iCurrAreaNumb];
            //Цикл по всем граничащим на предыдущей строке областям
            for (i=pAreasPrevBuf[i]; i<=iCurrAreaNumb; i++)
            {
                if (AreasMode[i]!=iCurrModeNumb) continue;
                //На предыдущей строке найдена область с совпадающей модой,
                //которая соседствует с исходной
                iDstIndex=i;
                while(AreasNumber[iDstIndex]!=iDstIndex) iDstIndex=AreasNumber[iDstIndex];
                if (iSrcIndex!=iDstIndex)
                {
                    //Объединение двух кластеров областей
                    if (iSrcIndex<iDstIndex)
                    {
                        //Сохранение номера
                        AreasNumber[iDstIndex]=iSrcIndex;
                    }
                    else
                    {
                        //Сохранение номера
                        AreasNumber[iSrcIndex]=iDstIndex;
                        //Для дальнейшего объединения берётся меньший индекс
                        iSrcIndex=iDstIndex;
                    }
                    //Декремент кол-ва областей
                    iAreasCounter--;
                }
            }
        }
        //Сохранение кол-ва областей
        iTmp=iAreasInfoCounter;
        //Ожидание окончания сохранения результата
        DAT_wait(id_SaveTransfer);
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasCurrBuf, Areas[y], sizeof(short)*Width);
    }

    //Обновление ссылок на области
    for (iSrcIndex=0; iSrcIndex<iAreasInfoCounter; iSrcIndex++)
    {
        //Поиск индекса назначения
        iDstIndex=iSrcIndex;
        while(AreasNumber[iDstIndex]!=iDstIndex) iDstIndex=AreasNumber[iDstIndex];
        //Обновление номера области
        AreasNumber[iSrcIndex]=iDstIndex;
    }

    //Могут оставаться независимые области с индексами больше iAreasCount
    for (iDstIndex=-1, iSrcIndex=iAreasCounter; iSrcIndex<iAreasInfoCounter; iSrcIndex++)
    {
        //Если эта область уже переадресована - все нормально
        if (AreasNumber[iSrcIndex]!=iSrcIndex) continue;
        //Поиск индекса для переадресации
        for (iDstIndex++; iDstIndex<iAreasCounter; iDstIndex++)
            if (AreasNumber[iDstIndex]!=iDstIndex) break;
        //Сохранение указателя на моду
        AreasMode[iDstIndex]=AreasMode[iSrcIndex];
        //Установка ссылки данной области на переадресованную
        AreasNumber[iSrcIndex]=iDstIndex;
        //Замена всех ссылок на эту область!!!!!!!!
        for (i=iSrcIndex; i<iAreasInfoCounter; i++)
            if (AreasNumber[i]==iSrcIndex) AreasNumber[i]=iDstIndex;
    }

    //Установка указателя на текущую загружаемую строку
    pAreasCurrBuf=AreasBuf[0];
    //Загрузка первой строки номеров областей
    id_LoadTransfer=DAT_copy(Areas[0], pAreasCurrBuf, sizeof(short)*Width);
    //Начальная инициализация идентификатора канала сохранения
    id_SaveTransfer=DAT_XFRID_WAITNONE;
    //Обработка всех строк
    for (y=0; y<Height; y++)
    {
        //Сохранение указателя на предыдущую строку результата
        pAreasPrevBuf=pAreasCurrBuf;
        //Указатель на следующую строку результата
        pAreasCurrBuf=AreasBuf[(y+1)&1];
        //Ожидание окончания загрузки текущей строки изображения
        DAT_wait(id_LoadTransfer);
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer=DAT_copy(Areas[y+1], pAreasCurrBuf, sizeof(short)*Width);
        //Переписывание индексов удалённых областей на переназначенные
        for (x=0; x<Width; x++) pAreasPrevBuf[x]=AreasNumber[pAreasPrevBuf[x]];
        //Ожидание окончания сохранения результата
        DAT_wait(id_SaveTransfer);
        //Сохранение строки результата
        id_SaveTransfer=DAT_copy(pAreasPrevBuf, Areas[y], sizeof(short)*Width);
    }
    //Ожидание окончания сохранения результата
    DAT_wait(id_SaveTransfer);

    return iAreasCounter;
}