Подскажите куда копать.

[PapooAss]

Всем доброго здоровьичка!
подскажите несведущему в какую сторону двигаться и где лучше копать?

Дано: графический файл в формате bmp. не шибко большого размера. в нем идут пиксели сначала одного цвета, затем другого. при чем длина пикселей одного цвета абсолютно разная.

Задача: попиксельно, построчно проанализировать файл и в местах стыка двух цветов-поставить взамен одного-другой-с усредненной цветовой гаммой (например белый-черный=серый)

как я вижу реализацию: в идеале хотелось бы иметь графический интерфейс, где можно из каталога выбрать файл, иметь возможность проверки в автоматичском режиме (по всей цветовой гамме) а так же иметь возможность выбрать принудительно цвет А и цвет Б и чтобы только ЭТИ цвета проверялись. Ну и чтобы сохранялся новый файл в заданную директорию.

[Aether]

Для начала определиться с целевой платформой, языком программирования, и инструментами, которые определят степень требуемого погружения в детали. Если это задание даёт преподаватель, то эти моменты стоит сперва уточнить у него.

[PapooAss]

Задача не учебная, а вполне себе реальная.
Платформа? Ну когда-то программировал в BASIC-е, еще на Spectrum.
еще в институте что-то там делал в VisualBasic.
сейчас пишу код только в 1С.
на нем точно эту задачу не выполнишь ))
поэтому ответ вопрос какая платформа, отвечу: какую посоветуете, какая эффективнее позволит с этим справиться. но чтобы без лишних заморочек. Простота и эффективность-вот мой слоган.

[Sla]

1c так 1c, чего дергаться?
Т.е. интрефейс по выбору файла у вас уже есть, осталось прикрутить только gdi

https://habrahabr.ru/post/176717/

[PapooAss]

1С не пойдет как платформа-поскольку компьютер не домашний, а значит должно отсутствовать нелицензионное ПО. А на покупку лицензии-вряд ли кто согласится. да и незачем. Я вижу это как отдельный исполняемый файл со встроенной формой интерфейса.

[Aether]

Платформа? Ну когда-то программировал в BASIC-е, еще на Spectrum.
еще в институте что-то там делал в VisualBasic.

поэтому ответ вопрос какая платформа, отвечу: какую посоветуете, какая эффективнее позволит с этим справиться. но чтобы без лишних заморочек.

Простота и эффективность-вот мой слоган.

Если речь об изучении нового языка, имхо, более профессионально "С/С++".

Если целевая платформа Windows, то в рамках языка можно использовать:
MS Visual Studio https://www.visualstudio.com/ru/downloads/

Если требуется кроссплатформенность, то:
Qt Creator https://www.qt.io/ide/

Заморочки - это будни, и их придётся решать - вдумчиво, шаг за шагом, досконально... От них не уйти, всегда будут ошибки - Ваши и чужие, всегда нюансы. Задача инженера разбираться и решать. Не всегда кажущийся путь оказывается кратчайшим.

Да, этот слоган я тоже люблю, самое простое, это отказаться от графического интерфейса, установить GIMP или Corel PhotoPaint или аналог в виде любого современного графического редактора, и в скрипте написать требуемую обработку. То, что Вы хотите сделать очень напоминает эффект размывания с шириной в один пиксель. Может это именно то, что нужно?

[Алексей++]

при чем длина пикселей одного цвета абсолютно разная.

а что есть длина пикселя ?

[Sla]

при чем длина пикселей одного цвета абсолютно разная.

а что есть длина пикселя ?

Это не важно - последовательность пикселей одного цвета

1С не пойдет как платформа-поскольку компьютер не домашний, а значит должно отсутствовать нелицензионное ПО.

Какого ПО?

Вы пробовали? то что в приведенном примере?

[PapooAss]

при чем длина пикселей одного цвета абсолютно разная.

а что есть длина пикселя ?

неправильно выразился. читать как последовательность пикселей одного цвета

Добавлено через 21 минуту и 50 секунд:

1С не пойдет как платформа-поскольку компьютер не домашний, а значит должно отсутствовать нелицензионное ПО.

Какого ПО?
Вы пробовали? то что в приведенном примере?
[/quote]
Давайте оставим этот разговор насчет 1С. это не подходит                                                         априори. Чуть позже я напишу полный алгоритм , по которому программа должна работать, с примерами и иллюстрациями.

[Алексей++]

PapooAss, как я понимаю, задача сводится к двум шагам:
1) увеличить изображение в 2 раза без антиалиазинга
2) обратно уменьшить в 2 раза с антиалиазингом

в результирующем изображении на границах цветовых областей произойдёт смешение цветов

[Aether]

в результирующем изображении на границах цветовых областей произойдёт смешение цветов

Добавлю: и куда результат записывать? Делить поровну от границы?

Предположим исходный фрагмент:

Код:

{
{255, 255, 255, 255,   0},
{255, 255, 255,   0,   0},
{255, 255,   0,   0,   0},
{255,   0,   0,   0,   0},
{  0,   0,   0,   0,   0}
};

Предположим результат:

Код:

{
{255, 255, 255, 127, 127},
{255, 255, 127, 127,   0},
{255, 127, 127,   0,   0},
{127, 127,   0,   0,   0},
{  0,   0,   0,   0,   0}
};

Так?

[Алексей++]

Aether,

а я вот идею то высказал, а как оно делается - даже не задумался сначала )) На пальцах попробовал - с ходу не осилил

Но я даже уверен, что всё это имеет какой-нибудь термин. Только я его не знаю

[Aether]

Но я даже уверен, что всё это имеет какой-нибудь термин. Только я его не знаю

Я тоже не знаю, как это называется.

Для меня была бы большая проблема в отработке формата. BMP лишь кажется простым, а на деле это контейнер с кучей разновидностей внутри. Худший вариант, когда внутри изображение с заданной палитрой, но самый распространённый вариант RGB24. В рамках Qt, если я правильно помню есть класс QImage, который позволяет уйти от проблем с загрузкой и сохранением изображения, и в то же время предоставляет прямой доступ к матрице пикселей.

Соответственно, если нет ограничения по объёму памяти в задании, то:
1) Создать приложение в QtCreator.
2) Создать объект QImage1. И загрузить в него изображение.
3) Создать объект QImage2 такого же размера, как QImage1.
4) Создать двойной цикл, и проехать им по всему полю обеих матриц. Не забыть при этом, что каждое поле цветов должно обрабатываться отдельно.
5) Расчётная формула у меня была бы для "смягчения" изображения по каждой отдельной плоскости цвета:
q2[i, j] = ( 8 * q1[i, j] +
q1[i + 1, j] + q1[i - 1, j] + q1[i, j + 1] + q1[i, j - 1] +
q1[i + 1, j + 1] + q1[i - 1, j + 1] + q1[i + 1, j - 1] + q1[i - 1, j - 1] ) / 16;
Можно, конечно, подойти и более интересно и правильно с точки зрения математики. Также в любом случае следует не забыть про граничные условия, то есть индекс, например, (i - 1) при i = 0 существовать не будет, но значение там быть должно - это зависит от стратегии, может быть всегда 0 - для образования мягкой рамки, а может быть значением ближайшего пикселя.
6) Сохранить результат в матрице q2 штатными средствами QImage.

[PapooAss]

вот алгоритм, по которому это должно работать. все посты выше об увеличении картинки и дальнейшем уменьшении-все не то.
http://s018.radikal.ru/i511/1701/82/5a4541d7de4e.jpg
вот пример: Слева-исходник, справа-то что должно получиться.

алгоритм:
1. Проходим (анализируем) по всей картинке, определяем основные цвета:
Серый (сер)
Красный (кр)
Синий (син)

2. Задаем основным цветам добавочные ассоциативные цвета:
Сер-> зелёный
Кр-> бордо
Син-> фиолетовый

3. Начинаем проход сверху вниз слева направо:
Сер? - Да! - запомнили
Сер?- да!- дальше ( повторяем)
Сер?- нет! Красный, заносим в эту ячейку добавочный цвет- бордо, и в предыдущую ячейку заносим дополнительный цвет- зелёный.
Идём дальше:
Следующая ячейка Серая ( опять поменялось)- значит туда зеленую, заносим в предыдущую (какая там была? Красная? Ок!) бордо туда!
Следующая опять серая? - начинай с начала цикла.

[Aether]

Определились с языком?

Подыскали по нему литературу?

Скачали ПО?

Вот это: RGB = {127, 127, 127}; - серый.

Вот это: RGB = {167, 167, 167}; - тоже серый, но светлее.

[PapooAss]

Определились с языком?

Подыскали по нему литературу?

Скачали ПО?

Вот это: RGB = {127, 127, 127}; - серый.

Вот это: RGB = {167, 167, 167}; - тоже серый, но светлее.

ну я собственно потому и обратился на этот форум, чтобы дельным советом подсказали какой язык лучше использовать.
начал скачивать Qt-там столько много версий, причем по дефолту ставится совсем немного. Мжет кто подскажет что именно мне потребуется а что не потребуется.
и по поводу разных оттенков серого-я не понял ремарки. Ну разные, ну и что. если изначально вся картинка прогоняется на наличие различных цветов.
много цветов в конкретном случае не будет. максимум 10, ну 15 отсилы. в основном 3-5

[Aether]

начал скачивать Qt-там столько много версий, причем по дефолту ставится совсем немного. Мжет кто подскажет что именно мне потребуется а что не потребуется.

и по поводу разных оттенков серого-я не понял ремарки. Ну разные, ну и что. если изначально вся картинка прогоняется на наличие различных цветов.
много цветов в конкретном случае не будет. максимум 10, ну 15 отсилы. в основном 3-5

1) Qt имеет онлайн инсталлятор, версия по умолчанию ставится последняя. По поводу компонентов сходу сказать сложно - перед глазами нет.

2) Ремарки по поводу того, что проработка математики должна быть более конкретной, ведь предстоит работать не с цветами, а с числами. В принципе, для точного описания алгоритма язык программирования не важен. Хотя до скачивания рекомендовал бы скачать учебник по "С/С++", чтобы оценить трудоёмкость его освоения, и если уж идти по пути получения профессиональных навыков, то идти осознанно.

[Алексей++]

Aether, абсолютно неважно, какой формат, мы говорит о пикселях. Подразумевается, что работаем, скажем, с RGB без всяких палитр

PapooAss, Qt - это не язык, это библиотека на языке C++. Ну а для самого алгоритма язык вообще неважен.

PapooAss, а вот по алгоритму - я понял, что хочется выделить границы цветовых областей. Но по скрину непонятно по правой стороне фигур - чойта там ничего не выделено ?

Предлагаю ещё такой алгоритм: попиксельно сканируется исходное изображение. Также предварительно есть заготовка для результата ( цвет заготовки неважен, там все пикселы закрасятся) - одинакового размера с исходником.  Для каждого пиксела исходника проверяется соседство (лево, верх, снизу, справа) и выбирается цвет пиксела и цвет соседнего пиксела для картинки результата (цвет как раз и выбирается в зависимости от перехода. Ну а переход для двух пикселов, само собой, определить несложно. Так же как и выбрать нужную замену цвета)

PS с ходу тут напрашивается оптимизация - проверять не 4 стороны пиксела, а только, скажем, справа и снизу

[PapooAss]

PapooAss Но по скрину непонятно по правой стороне фигур - чойта там ничего не выделено ?

Все верно, проверка должна проходить ТОЛЬКО в одном направлении (столбцы либо строки).
Чтобы было понимание для чего это нужно-есть трикотажное производство с ЧПУ. необходимо задать программе команду на перестроение ниток. для этого и надо обозначить контрольные пикселы для выбора того или иного цвета ниток. Ну а если кто сталкивался с этой отраслью промышленности-там идет "ручейками" нитки.  Именно поэтому проверка только в одном направлении

[Алексей++]

PapooAss, вот и подошли к сути - написание ТЗ Оказывается, алгоритм вовсе не абстрактный, а очень даже завязан на механику реального процесса

Мой последний алгоритм вполне подходит с небольшими правками

[Aether]

Да, ТЗ интересно было бы почитать, как и описание работы текстильного станка. Получается, нужно сделать для него управляющую программу - загружаем изображение, а программа строит план: где пойдёт какая основа, и где будет какая утка?

[PapooAss]

Активные поиски по просторам интернета натолкнули меня на редактор Paint.Net
Она бесплатная-это то, что надо да и к тому же есть возможность написания плагинов при помощи библиотеки CodeLab.
Тот же С#. Буду ковырять в этом направлении. Как сделаю-отпишусь. ))

[Алексей++]

PapooAss, так это всего лишь графический редактор, там программы не пишутся

вот ещё одна идея, как выделить граничные пикселы: если копию изображения сдвинуть на пиксел вниз и вычесть из исходника, то получаться не нулевые цвета там, где снизу переходы цветов. Такую же операцию нужно проделать со сдвигом на 1 пиксел вверх. Затем обе маски наложить на исходник

И - исходник
И1 - сдвиг на 1 вниз
И2 - сдвиг на 1 вверх
M1 = И - И1
M2 = И - И2
Р - результат

И  И1  И2     М1    М2     Р

       1
1  *   1      *     0      1
1  1   1      0     0      1
1  1   2      0    -1     -1    <--- переход
2  1   2      1     0      1    <--- переход
2  2   2      0     0      2
2  2   *      0     *      2
   2

[PapooAss]

PapooAss, так это всего лишь графический редактор, там программы не пишутся

вот ещё одна идея, как выделить граничные пикселы: если копию изображения сдвинуть на пиксел вниз и вычесть из исходника, то получаться не нулевые цвета там, где снизу переходы цветов. Такую же операцию нужно проделать со сдвигом на 1 пиксел вверх. Затем обе маски наложить на исходник

И - исходник
И1 - сдвиг на 1 вниз
И2 - сдвиг на 1 вверх
M1 = И - И1
M2 = И - И2
Р - результат

И  И1  И2     М1    М2     Р

       1
1  *   1      *     0      1
1  1   1      0     0      1
1  1   2      0    -1     -1    <--- переход
2  1   2      1     0      1    <--- переход
2  2   2      0     0      2
2  2   *      0     *      2
   2

интересная идея, не спорю. но мне кажется сложновата.
1. цвет не передается одной цифрой. А значит придется мудрить постоянные проверки сразу как минимум по 3 составляющим, либо присваивать каждому цвету-свой номер. Хорошо если их 2. А если 10? Вот тут и возникает вопрос номер 2.
2. в данном примере 1 переход между цветами. а если будет "1112221211"-уже как минимум 4 перехода. Ок алгоритм отработает, мы получим в результате необходимые нам 1 и -1. Сравним с исходником, обнаружим переходы. Дальше что? как понять что за цвет должен быть в том или ином месте.
вот пример:

И  И1  И2     М1    М2     Р

       1
1  *   1      *     0      1
1  1   2      0     -1      -1    <--- переход
2  1   2      1       0     1    <--- переход
2  2   3      0     -1      -1    <--- переход
3  2   3      1      0      1    <--- переход
3  3   *      0     *      3
   3

В итоге, если мы присвоим каждому такому состоянию перехода свой цвет-то получится что ячейки с "2" будут иметь разные цвета на границе сверху и снизу! (выделены желтым). А они должны быть одинаковые

[Aether]

Как мини пример:

Код: (C)

#include <stdio.h>

#define WIDTH 5
#define HEIGHT 5

typedef struct {
    unsigned char cRed;
    unsigned char cGreen;
    unsigned char cBlue;
    unsigned char cAlpha;
} RGB;

int main(int argc, char* argv)
{
    static RGB ppsSrc[WIDTH][HEIGHT] = {
        {{127, 127, 127, 0}, {127, 127, 127, 0}, {127, 127, 127, 0}, {127, 127, 127, 0}, {0, 0, 0, 0}},
        {{127, 127, 127, 0}, {127, 127, 127, 0}, {127, 127, 127, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{127, 127, 127, 0}, {127, 127, 127, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{127, 127, 127, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},
        {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}
        };

    static RGB ppsDst[WIDTH][HEIGHT];

// Обработка
    for (int iY = 0; iY < HEIGHT; iY++) {

        for (int iX = 0; iX < WIDTH; iX++) {

            char tcRed = ppsSrc[iX][iY].cRed;
            char tcGreen = ppsSrc[iX][iY].cGreen;
            char tcBlue = ppsSrc[iX][iY].cBlue;

            if (iX != WIDTH - 1) {

                char tcRed_next = ppsSrc[iX + 1][iY].cRed;
                char tcGreen_next = ppsSrc[iX + 1][iY].cGreen;
                char tcBlue_next = ppsSrc[iX + 1][iY].cBlue;

                if ((tcRed != tcRed_next) ||

                    (tcGreen != tcGreen_next) ||
                    (tcBlue != tcBlue_next)) {

                    ppsDst[iX][iY].cRed = (unsigned char)255;
                    ppsDst[iX][iY].cGreen = (unsigned char)255;
                    ppsDst[iX][iY].cBlue = (unsigned char)255;

                } else {

                    ppsDst[iX][iY].cRed = ppsSrc[iX][iY].cRed;
                    ppsDst[iX][iY].cGreen = ppsSrc[iX][iY].cGreen;
                    ppsDst[iX][iY].cBlue = ppsSrc[iX][iY].cBlue;

                }
            } else {

                ppsDst[iX][iY].cRed = ppsSrc[iX][iY].cRed;
                ppsDst[iX][iY].cGreen = ppsSrc[iX][iY].cGreen;
                ppsDst[iX][iY].cBlue = ppsSrc[iX][iY].cBlue;

            }
        }
    }

// Вывод исходного
    printf("\nSrc:\n");

    for (int iY = 0; iY < HEIGHT; iY++) {

        for (int iX = 0; iX < WIDTH; iX++) {

            printf("{%3u - %3u - %3u} ", ppsSrc[iX][iY].cRed,
                                         ppsSrc[iX][iY].cGreen,
                                         ppsSrc[iX][iY].cBlue);
        }
    printf("\n");
    }

// Вывод полученного
    printf("\nDst:\n");

    for (int iY = 0; iY < HEIGHT; iY++) {

        for (int iX = 0; iX < WIDTH; iX++) {

            printf("{%3u - %3u - %3u} ", ppsDst[iX][iY].cRed,
                                         ppsDst[iX][iY].cGreen,
                                         ppsDst[iX][iY].cBlue);
        }
    printf("\n");
    }

return 0;
}

Результат:

Src:
{127 - 127 - 127} {127 - 127 - 127} {127 - 127 - 127} {127 - 127 - 127} {  0 -   0 -   0}
{127 - 127 - 127} {127 - 127 - 127} {127 - 127 - 127} {  0 -   0 -   0} {  0 -   0 -   0}
{127 - 127 - 127} {127 - 127 - 127} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}
{127 - 127 - 127} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}
{  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}

Dst:
{127 - 127 - 127} {127 - 127 - 127} {127 - 127 - 127} {255 - 255 - 255} {  0 -   0 -   0}
{127 - 127 - 127} {127 - 127 - 127} {255 - 255 - 255} {  0 -   0 -   0} {  0 -   0 -   0}
{127 - 127 - 127} {255 - 255 - 255} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}
{255 - 255 - 255} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}
{  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0} {  0 -   0 -   0}

Алексей++, если сдвинуть изображение на 1 пиксель вправо и перемножить с оригиналом, то этого ему будет достаточно, но тогда грани объектов будут выделены с обеих сторон, а ему, как понял, нужно только с фронта. Вообще, нужно подробное ТЗ, чётко сформулированное - обычно его грамотное составление - это уже решение задачи на половину.

[Алексей++]

PapooAss, цвет в RGB - это всегда одна цифра, тут всё нормально. Я лишь показываю, как переходы можно обнаружить - довольно несложно. А вот что дальше с этой информацией делать нужно придумать, как их там правильно раскрасить. Я сам техпроцесс пока что не представляю, поэтому дальше и не предлагаю ничего

[PapooAss]

В общем задача такова:
Необходимо в местах перехода цветов с обоих границ поменять цвета на любые другие, не важно на какие, лишь бы они не совпадали с уже имеющимися.
При этом проверка должна осуществляться только по столбцам. Смена границ в строках-не имеет значения.

[Aether]

В общем задача такова:
Необходимо в местах перехода цветов с обоих границ поменять цвета на любые другие, не важно на какие, лишь бы они не совпадали с уже имеющимися.

При этом проверка должна осуществляться только по столбцам. Смена границ в строках-не имеет значения.

Уже привели такие идеи, дело за конкретикой и реализацией. Ваша задача описать желаемое, начать разработку, а участники по мере наличия сил и желания попробуют поспособствовать реализации.

Вот как, например, обеспечить так, чтобы цвета не совпадали? Это либо создание карты исходных цветов, с чётко оговорёнными параметрами, либо переход от BMP, который тут особо и не нужен к матрицам увеличенной разрядности. Возможно проще реализовать отдельную матрицу границ?

[Алексей++]

PapooAss, можно сначала определить все использующиеся цвета, выделить 2 новых (неиспользованных) цвета для обозначения переходов. Их и использовать

[PapooAss]

Задачу решил.
Как и задумывал-в виде плагина к программе Paint.Net.
Если кому интересно-могу выложить готовый плагин.
Всем большое спасибо за участие и идеи. Отличный форум. Пожалуй пропишусь тут ))