операторы для ARGB

[Denjs]

К теме "удобства"?
Почему "для удобства" не использовать функцию интерполяции, с предопределенными в ноль значениями аргументов?

Код:

argb interpolate(argb *color1, argb *color2, argb *color3=0, argb *color4=0, argb *color5=0, argb *color6=0, argb *color7=0, argb *color8=0);

Наверняка - более 8 точек (или скажем 10) вы наврятли будете "интерполировать".

"Заряжать массивы" не надо, можно указывать произвольное количество аргументов, а в самой функции - использовать тот или иной алгоритм в зависимости от количества не-нулевых аргументов.

[spectre71]

Отсутствует Ассоциативность, а не Коммутативность
С1+С2+С3 != С2+С3+С1
Но поскольку имеем Ассоциативность, то
С1+С2 == C2+C1 =>                               
(С1+С2)+С3 == (C2+C1)+C3 равносильно такой записи С1+С2+С3 == C2+C1+C3

И в чём тогда проблема? Или я чего-то не вкуриваю.. 

Вот это неравно!!! С1+С2+С3 != С2+С3+С1
Хотя это равно!!!  С1+С2+С3 == C2+C1+C3

[Igors]

К теме "удобства".
Почему "для удобства" не использовать функцию интерполяции, с предопределенными в ноль значениями аргументов?

Можно, но ведь коэффициенты тоже надо передать, итого получается 16 
А главное - это не засунуть в template и мне придется городить такую монстр-функцию и для др. типов

И в чём тогда проблема? Или я чего-то не вкуриваю.. 

Я полагаю (возможно ошибаюсь) что "видимые" цвета (т.е. цвет умноженный на альфа) можно "просто смешивать". Разумеется потом надо "вернуть цвет взад" поделив на альфу. Вопрос в том как технично это оформить

[spectre71]

Я понимаю что не удобно. Но нельзя муху превратить в слона.
Пример я привел выше. Он математически обоснован.

С123 = С1+С2+С3;
С231 = С2+С3+С1;
С132 = С1+С3+С2;

С123 != С231;
С123 != С132;
С231 != С132;

Если они не лежат на оной прямой вы никак не заставите их быть равными, как ни старайтесь

В операторе предложенном m_ax - согласен, не равны. Но не вижу почему они не равны для операторов предложенных в посте #21. Заметим что каждое слагаемое должно сначала на что-то множиться (premultiply alpha)

Вот именно что должны множиться. Поэтому операции + и * по отдельности не имеют смысла.
Что у вас и показано в том примере

ARGB result1 = (c1 + c2) / 2;  // так ничего хорошего не получится ;-)
ARGB result2 = (c1 * 0.5f + c2 * 0.5f) / 1.0f;  // a так ?
ARGB result3 = (c1 * 0.125f + c2 * 0.5f + с3 * 0.375f) / 1.0f;  // или так ?

Мало того это еще и менее эффективно с точки зрения кол-ва вызовов функций(операция это функция).

Вам нужна функция F(C1, C2, K)
Тогда:
сложение 2-х: F(C1, C2, K1)
сложение 3-х: F(F(C1, C2, K1)), C3, K2)
сложение 4-х: F(F(F(C1, C2, K1)), C3, K2), C4, K3)
Или записав подугому:
C12 = F(C1, C2, K1)
C123 = F(C12, C3, K2)
C1234 = F(C123, C4, K3)
сложение N: ...

====================
Как вариан использования для некоторого удобства именно операции +. Можно слегка извратиться и сделать промежуточный класс Pair - Объединяющий цвет и коэффициент

inline ARGB::ARGB operator +  (const Pair  &p) const;

Тогда это:
 F(F(F(C1, C2, K1)), C3, K2), C4, K3)
Будет выглядеть так:

C = С1 + Pair(C2, K1) + Pair(C3, K2) + Pair(C4, K3);

[Denjs]

К теме "удобства".
Почему "для удобства" не использовать функцию интерполяции, с предопределенными в ноль значениями аргументов?

Можно, но ведь коэффициенты тоже надо передать, итого получается 16  

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

тогда вызов interpolate описанной как

Код:

argb interpolate(argb *color1, argb *color2, argb *color3=0, argb *color4=0, argb *color5=0, argb *color6=0, argb *color7=0, argb *color8=0);

будет достаточно прозрачен:

Код:

rez=interpolate ( &(0.3*argb1), &(0.4*argb2), &(0.5*argb3) );

А главное - это не засунуть в template и мне придется городить такую монстр-функцию и для др. типов

Да. вы же не засунете в шаблон операции умножения  числа и вектора. увы.
И много там у вас - этих "разных типов"? и какие например?
может проще определить это все в виде классов, ваши типы - наследовать от родительского, а в функции - использовать ссылки на родительский тип?

зачем вам вообще понадобилось использовать "template"?

[Igors]

C = С1 + Pair(C2, K1) + Pair(C3, K2) + Pair(C4, K3);

Ну а C1 что - лучше всех?   Я прикидывал так

Код

C++ (Qt)
result = (C1.Mul(k1) + C1.Mul(k2) + ..).Div(k1 + k2 + ..);
 

Но сопля все равно длинная  

Определите для вашего argb функцию умножения. Подозреваю, будет достаточно умножить на коэффициент ваш альфа-канал.

Так и сделал (пост #21)

И много там у вас - этих "разных типов"? и какие например?

Перечислил в посте #34

[spectre71]

Как вариан использования для некоторого удобства именно операции +. Можно слегка извратиться и сделать промежуточный класс Pair - Объединяющий цвет и коэффициент

inline ARGB::ARGB operator +  (const Pair  &p) const;

Тогда это:
 F(F(F(C1, C2, K1)), C3, K2), C4, K3)
Будет выглядеть так:

C = С1 + Pair(C2, K1) + Pair(C3, K2) + Pair(C4, K3);

Можно пойти несколько дальше

inline ARGB ARGB::operator +  (const Pair  &p) const;
inline ARGB ARGB::operator +  (const ARGB  &c) const; {return *this + Pair(c, 0.5);}
inline Pair  ARGB::operator *  (float  k) const; {return Pair(*this, k);}
Тогда будем иметь, например:

C = С0  + С1 + C2*K1 + C3*K2 + C4*K3;

С0  + С1 <==> С0  + С1*0.5

[spectre71]

C = С1 + Pair(C2, K1) + Pair(C3, K2) + Pair(C4, K3);

Ну а C1 что - лучше всех?  

В предыдущем моем посте

Ну а C1 что - лучше всех? 

Естественно, поскольку коэффициентов на 1 меньше чем цветов.

[spectre71]

Я прикидывал так

Код

C++ (Qt)
result = (C1.Mul(k1) + C1.Mul(k2) + ..).Div(k1 + k2 + ..);
 

Но сопля все равно длинная  

Я кажется понял что имелось ввиду.

k1, k2, ..., kn - это веса

Эту схему тоже можно привести к
result = C1*k1 + C2*k2 + ... + Cn*kn;
если где-то множитель k отсутствует, то считается равным 1.

Причем вычисление будет осуществлятся в последний момент!
Операциии "+" и "*" делают накопление данных - Цепочка вложенных Pair.
Это необходимо для вычисления (k1 + k2 + ... + kn).
А при присвоении уже делается расчет (преобразование накопленной цепочки - объекта Pair в ARGB).

[Denjs]

И много там у вас - этих "разных типов"? и какие например?

Перечислил в посте #34

и что? вы хотите произвольно указывать в вашей функции аргументы разных типов? вместо того, что бы описать нормальные 4 функции?

- float числа
- тройки чисел (x, y, z)
- RGB
- ARGB

Определяйте наследника класса QVariant - что бы он умел поддерживать ещё и "тройки чисел", "RGB", "ARGB" - и определяйте для него ваши операции.
Тогда и в шаблон думаю засунете. (или идите программировать на бейсике - там нет строгой типизации).

[spectre71]

Короче с классами что-то типа того:

Код:

class Pair {
  ARGB color;
  float k;
  Pair* next;

  Pair(const ARGB& c) {color = c, k=1, next=0;}
  Pair(const ARGB& c, float k) {color = c, this->k=k, next=0;}
  Pair(const Pair& p) {
    c= p.c;
    k= p.k;
    next= p.next;
  }
  Pair(const Pair& p, const Pair& next) {
    c= p.c;
    k= p.k;
    this->next= next;
  }
  
  ARGB calculateColor() const {...}


  inline operator ARGB () const {return calculateColor();}
  inline Pair operator  + (const Pair& p) const {return Pair(*this, p);}
  inline Pair friend operator + (const Pair& p1, const Pair& p2) {return Pair(p1, p2);}
};


class ARGB {

  inline Pair  operator *  (float  k) const; {return Pair(*this, k);}
};

[Denjs]

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

В итоге - Половина топика  это, имхо, флейм и рассуждения на уровне математического доказательства "женщины=проблемы"

(кто там анекдот хотел? получите рапишитесь))

[spectre71]

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

Не согласен!
Собственно тема постепенно и ракрывала абстрактное "хочу примерно того" в "необходимо именно это".
Насколько я понял автора, приведенное мной выше решение, то что ему нужно. А как он конкретно будет делать интерполяцию - его личное дело.
О чем он и говорит здесь #2.
Задача была именно в удобстве использования:
C1 + C2*x + C3 + C4 + C5*y ...

[Igors]

Пытаться определять операции над элементами, без описания собственно самого пространства,

Что ж то за "пространство" которого так не хватат? RGB и ARGB прекрасно определенные вещи, более того - это самая популярная цветовая модель.

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

Почему простое слово "интерполяция" или даже проще "вычислить среднее 2-х значений" недостаточно? Зачем загромождать форум техническими подробностями моей задачи которые не имеют к делу никакого отношения?

Короче с классами что-то типа того:

Хмм... ну а зачем мне заводить еще класс, конвертировать туда-сюда и.т.п.? Выглядит никак не проще. Чем плохи операторы предложенные в посте #21? Ну или ф-ции Mul и Div?
 

[Igors]

Задача была именно в удобстве использования:
C1 + C2*x + C3 + C4 + C5*y ...

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