Tweetable математическое искусство [закрыто]


330

Целочисленная математика может генерировать удивительные шаблоны, когда выкладывается по сетке. Даже самые основные функции могут привести к потрясающе сложным проектам!

Ваш вызов

Напишите 3 тела функции Tweetable (т.е. 140 символов или менее) для значений красного, зеленого и синего для изображения 1024x1024.

Входными данными для функций будут два целых числа i (номер столбца для данного пикселя) и j (номер строки для данного пикселя), а на выходе будет короткое число без знака от 0 до 1023 включительно, которое представляет сумму заданного цвет присутствует в пикселе (i, j).

Например, следующие три функции создают картинку ниже:

/* RED */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)*_sq(j-DIM/2))*2.0);
/* GREEN */
    return (unsigned short)sqrt((double)(
        (_sq(i-DIM/2)|_sq(j-DIM/2))*
        (_sq(i-DIM/2)&_sq(j-DIM/2))
    )); 
/* BLUE */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)&_sq(j-DIM/2))*2.0);

Узор-1

/* RED */
    return i&&j?(i%j)&(j%i):0;
/* GREEN */
    return i&&j?(i%j)+(j%i):0;
/* BLUE */
    return i&&j?(i%j)|(j%i):0;

Шаблон-2

Правила

  • Учитывая этот код C ++ , подставьте в свои функции. Я предоставил несколько макросов и включил библиотеку, и вы можете включить complex.h. Вы можете использовать любые функции из этих библиотек и / или моих макросов. Пожалуйста, не используйте никаких внешних ресурсов, кроме этого.
  • Если эта версия не работает для вас, убедитесь, что вы компилируете с:

    g++ filename.cpp -std=c++11
    

    Если это не сработает, используйте альтернативную версию с использованием беззнаковых символов вместо беззнаковых.

Michaelangelo предоставил исправленную 24-битную или 48-битную версию цветного вывода .

  • Вы можете реализовать свою собственную версию на другом языке, но она должна вести себя так же, как предоставленная версия C ++, и только функции из встроенных компонентов C ++, библиотеки или предоставленных макросов могут быть использованы для обеспечения ее справедливости.
  • Размещайте только три ваших функциональных тела - пожалуйста, не включайте мой код в ваше сообщение
  • Пожалуйста, включите уменьшенную версию или встроенную копию вашего изображения. Они сделаны в формате ppm и, возможно, должны быть преобразованы в другой для правильного просмотра на stackexchange.
  • Тела функций (не включая подпись) должны содержать не более 140 символов.
  • Это конкурс популярности - большинство голосов выигрывает

3
Добавлен тег C ++, поскольку природа правил исключает другие языки. Мы обычно предпочитаем языковые проблемы, если у них нет веских причин требовать определенного набора.
алгоритмическая

4
Если избиратели называют это слишком широким, попробуйте сначала написать ответ. Это удивительно ограничительно ...
trichoplax

8
Это моя любимая вещь, которую я видел здесь, как никогда!
Дэвид Конрад

4
Мне нравится, что этот вопрос напоминает демонстрационную сцену старой школы.
mskfisher

23
Этот тип вопроса поощряет участие в коде гольф . Я вообще не склонен отвечать на прямой вопрос о гольфе, так как я не уверен в том, что у меня все хорошо. С этим типом вопроса ограничение байтов заставляет меня пробовать простой ответ, изучать техники игры в гольф и затем использовать их, чтобы делать более сложные ответы. Это похоже на трамплин в ответе на прямые вопросы о гольфе. Я думаю, что это может быть ключевым для привлечения большего количества людей.
trichoplax

Ответы:


120

Мандельброт 3 х 133 символа

Первое, что пришло мне в голову, было «Мандельброт!».

Да, я знаю, что уже есть представление Мандельброта. После подтверждения того, что я могу получить его длиной менее 140 символов, я применил уловки и оптимизации этого решения (спасибо Мартину и Тодду). Оставалось место для выбора интересного местоположения и масштабирования, а также приятной цветовой темы:

Мандельброт

unsigned char RD(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,3.);
}
unsigned char GR(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.7);
}
unsigned char BL(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.5);
}

Всего 132 символа

Я попытался снизить его до 140 для всех 3 каналов. Рядом с краем есть немного цветового шума, и местоположение не так интересно, как первый, но: 132 символа

Мандельброт восстановленное

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}

8
Эти цвета великолепны!
Мартин Эндер

Я люблю этот, самый красивый образ пока!
Рой ван Рейн

4
Это мои обои сейчас.
Шифр

209

Скатерти

Плоский

Я начал рисовать узор в клетку / ситцевом кресле, как бескрайнюю скатерть:

unsigned char RD(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}

плоская скатерть

пульсация

Затем я представил рябь (не совсем правильная перспектива, но все же в 140 символов):

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}

рифленая скатерть

Цвет

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

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;
}

цветная скатерть

В движении

Немного большее уменьшение кода позволяет определить фазу волны P с двумя десятичными знаками, что достаточно для кадров, достаточно близких для плавной анимации. На этой стадии я уменьшил амплитуду, чтобы избежать морской болезни, и сдвинул все изображение еще на 151 пиксель (за счет одного лишнего символа), чтобы вытеснить алиасинг с верхней части изображения. Анимированные псевдонимы завораживают.

unsigned char RD(int i,int j){
#define P 6.03
float s=3./(j+250),y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;}

unsigned char GR(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;}

unsigned char BL(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;}

анимированная скатерть


15
Это легендарно. (Y) Так держать. : P
Мухаммед Ариб Сиддики

Но как именно реализовано движение? В оригинальном фреймворке нет логики смены кадров, не так ли?
Начиная с

2
@esteewhy можно создавать только неподвижные изображения. GIF показывает последовательность неподвижных кадров, каждый из которых был получен путем изменения значения после #define P. Это потребовало игры в гольф, чтобы допустить дополнительных персонажей #define P 6.03.
trichoplax

4
СТОП! Вы действительно хотите высказать лучший ответ? Есть несколько гораздо более интересных, если вы прокрутите вниз на следующих двух страницах.
Трихоплакс

1
Я рекомендую отсортировать ответы по «самым старым», и тогда вы сможете увидеть, как развивались новые подходы с появлением новых ответов.
trichoplax

192

Случайный художник

введите описание изображения здесь

char red_fn(int i,int j){
#define r(n)(rand()%n)
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):red_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char green_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):green_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char blue_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):blue_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}

Вот случайная запись. Для около 0,1% пикселей он выбирает случайный цвет, для других он использует тот же цвет, что и случайный соседний пиксель. Обратите внимание, что каждый цвет делает это независимо, так что на самом деле это просто наложение случайного зеленого, синего и красного изображения. Чтобы получить разные результаты на разных прогонах, вам нужно добавить srand(time(NULL))в mainфункцию.

Теперь о некоторых вариациях.

Пропуская пиксели, мы можем сделать его более размытым.

введите описание изображения здесь

И тогда мы можем медленно менять цвета, где переполнение приводит к резким изменениям, которые делают это еще более похожим на мазки кисти

введите описание изображения здесь

Вещи, которые мне нужно выяснить:

  • По какой-то причине я не могу использовать srandэти функции без ошибки.
  • Если бы я мог сделать случайные прогулки одинаковыми для всех трех цветов, это могло бы выглядеть немного более упорядоченно.

Вы также можете сделать случайную прогулку изотропной, как

static char c[1024][1024];return!c[i][j]?c[i][j]=r(999)?red_fn((i+r(5)+1022)%1024,(j+r(5)+1022)%1024):r(256):c[i][j];

чтобы дать тебе

введите описание изображения здесь

Более случайные картины

Я немного поиграл с этим и создал несколько других случайных картин. Не все из них возможны в рамках ограничений этой задачи, поэтому я не хочу включать их здесь. Но вы можете увидеть их в этой галерее imgur вместе с некоторыми описаниями того, как я их создал.

Я испытываю желание развить все эти возможности в рамках и положить его на GitHub. (Не то чтобы такого не было, но все равно весело!)


12
Я люблю это. Я не знал, что можно будет учитывать соседние пиксели, не имея доступа к данным пикселей - плавная работа!
Трихоплакс

1
Мне очень напоминает этот старый конкурс, где правила должны были помещать пиксель каждого цвета в изображение.
интернет сделан из catz

2
Вау! Эти картинки абсолютно красивые!
raptortech97

1
Классная галерея, радиальные аккуратные.
интернет сделан из catz

2
Я вижу Reptar : последнее изображение в посте (изотропное), верхний правый сектор.
Тим Педерик

162

Некоторые острые вещи

Да, я точно знал, как это назвать.

Некоторые острые вещи

unsigned short RD(int i,int j){
    return(sqrt(_sq(73.-i)+_sq(609-j))+1)/(sqrt(abs(sin((sqrt(_sq(860.-i)+_sq(162-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(160.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(86.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(844.-i)+_sq(200-j))+1)/(sqrt(abs(sin((sqrt(_sq(250.-i)+_sq(20-j)))/115.0)))+1)/200;
}

РЕДАКТИРОВАТЬ: больше не использует pow. РЕДАКТИРОВАТЬ 2: @PhiNotPi указал, что мне не нужно использовать пресс столько же.

Вы можете довольно легко изменить контрольные точки, чтобы получить другую картину:

Некоторые более острые вещи

unsigned short RD(int i,int j){
    return(sqrt(_sq(148.-i)+_sq(1000-j))+1)/(sqrt(abs(sin((sqrt(_sq(500.-i)+_sq(400-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(610.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(864.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(180.-i)+_sq(100-j))+1)/(sqrt(abs(sin((sqrt(_sq(503.-i)+_sq(103-j)))/115.0)))+1)/200;
}

@EricTressler указал, что на моих фотографиях есть Бэтмен.

Бэтмен


1
@JayKominek Я бы не знал, меня тогда не было. D:
cjfaure


1
@ cjfaure Ого! благодарю вас! похоже, что окончательная версия описания находится по адресу: web.archive.org/web/20031205062033/http://www.blorf.com/~mrad/… и код был перемещен в sourceforge. обновлено даже в прошлом году! sourceforge.net/projects/libswirlies
Джей Коминек,

1
Один из любимых!
Увлечения Кэлвина

1
Этот хорош - но я не могу воспроизвести его вообще! Самое близкое, что я могу получить, - это когда PPM генерируется неправильно (LSB вместо MSB), и даже тогда он просто выглядит как множество альфа-смешанных кругов разного цвета.
DreamWarrior

123

Конечно, Мандельброт должен быть представлен.

введите описание изображения здесь

char red_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>31?256:k*8;
}
char green_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>63?256:k*4;
}
char blue_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k;
}

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

Изменить: действительно трудно придумать приличные цветовые схемы с этими немногими оставшимися байтами. Вот еще одна версия:

/* RED   */ return log(k)*47;
/* GREEN */ return log(k)*47;
/* BLUE  */ return 128-log(k)*23;

введите описание изображения здесь

И согласно предложению githubphagocyte и с улучшениями Тодда Лемана, мы можем легко выбрать меньшие секции:

Например

char red_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char green_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char blue_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return 128-k/200;
}

дает

введите описание изображения здесь


12
@ tomsmeding Я должен признаться, это первый раз, когда я реализовал набор Мандельброта.
Мартин Эндер

2
Столь же знаковый, как и полный набор Мандельброта (+1, кстати!), Похоже, что вы оставили себе достаточно места, чтобы отрегулировать параметры и опубликовать ответ с некоторыми изумительно скрученными деталями глубокого увеличения.
Трихоплакс

1
@githubphagocyte Я уже думал об этом, но все еще не удосужился перекомпилировать, перезапускать и конвертировать каждый раз, пока не выяснил приличные параметры;). Могу сделать это позже. Сначала я должен попробовать совершенно другую функцию. ;)
Мартин Эндер

2
@githubphagocyte наконец-то нашел время, чтобы добавить это. спасибо за предложение!
Мартин Эндер

2
Спасибо @Todd, я обновил окончательную картину с этим. Я использовал 25600 итераций, что слишком долго. ;)
Мартин Эндер

110

Юлия сет

Если есть Мандельброт, там тоже должен быть набор Джулии.

введите описание изображения здесь

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

Вдохновленный участием Мартина.

unsigned short red_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.)
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(X=x*x)+(Y=y*y)<4){x=X-Y+.36237;y=2*x*y+.32;}return log(n)*256;}

unsigned short green_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+-.7;y=2*X*Y+.27015;}return log(n)*128;}

unsigned short blue_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<600&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+.36237;y=2*X*Y+.32;}return log(n)*128;}

Хотите немного ГСЧ?

Хорошо, комментарий Спарра поставил меня на путь, чтобы рандомизировать параметры этих маленьких Джулиас. Сначала я попытался взломать на битовом уровне результат, time(0)но C ++ не допускает шестнадцатеричные литералы с плавающей точкой, так что это был тупик (по крайней мере, с моими ограниченными знаниями). Я мог бы использовать для этого тяжелое приведение, но это не вписалось бы в 140 байтов.

В любом случае у меня осталось не так много места, поэтому я должен был бросить красную Джулию, чтобы поставить свои макросы и получить более обычный ГСЧ ( буду timeпосевным и реальным rand(), ууууу!).

введите описание изображения здесь

К сожалению, чего-то не хватает. Очевидно, что эти параметры должны быть статическими, иначе у вас будут какие-то странные результаты (но забавно, может быть, я рассмотрю немного позже, если найду что-нибудь интересное).

Итак, мы с зелеными и синими каналами:

введите описание изображения здесь

введите описание изображения здесь

введите описание изображения здесь

Теперь давайте добавим простой красный шаблон, чтобы заполнить пустоту. Не очень творчески, но я не графический программист ... пока :-)

введите описание изображения здесь

введите описание изображения здесь

И, наконец, новый код со случайными параметрами:

unsigned short red_fn(int i, int j){
static int n=1;if(n){--n;srand(time(0));}
#define R rand()/16384.-1
#define S static float r=R,k=R;float
return _cb(i^j);}

unsigned short green_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.),
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

unsigned short blue_fn(int i, int j){
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

Там еще осталось место ...


у вас есть место для рандомизации параметров каждого запуска с srand (time (0) и rand ()? или просто time (0)?)
Sparr

2
Этот последний идет на моей стене.
cjfaure

@Sparr обновлен вашим предложением. Повеселился :-).
интернет сделан из catz

4
Я не могу сказать, что нравится больше всего: ваш ответ или ваше имя пользователя
Уильям Барбоза

107

Это интересно, потому что в нем вообще не используются параметры i, j. Вместо этого он запоминает состояние в статической переменной.

unsigned char RD(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char GR(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char BL(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}

красочный


Было бы интересно увидеть результаты этого кода на разных платформах / компиляторах. Значение RAND_MAX варьируется в широких пределах и может дать совершенно разные изображения ...
trichoplax

5
Это не должно сильно измениться. (double) rand () / RAND_MAX всегда должен находиться в диапазоне [0.0, 1.0].
Мануэль Кастен

2
Это один из моих любимых!
Увлечения Кэлвина

2
Это не только интересно - это красиво!
Мартин Тома

104

Образ

/* RED */
    int a=(j?i%j:i)*4;int b=i-32;int c=j-32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
/* GREEN */
    int a=(j?i%j:i)*4;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((i+j)/2))^_cb((i-j)*2);
/* BLUE */
    int a=(j?i%j:i)*4;int b=i+32;int c=j+32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);

3
Это действительно красиво, +1.
Майло

3
Это мое любимое. Это похоже на профессионально сделанный графический элемент. : D
cjfaure

4
Похоже на вафлю из микропроцессора. macrophotographer.net/images/ss_rvsi_5.jpg
s0rce

Это выглядит как минималистские обои .
AL


82

Буддхаброт (+ Антибуддхаброт)

Редактировать: Теперь это настоящий Буддхаброт!

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

Я действительно хотел остановиться после четырех ... но ...

введите описание изображения здесь

Это слегка сжимается во время загрузки (и сокращается при встраивании), поэтому, если вы хотите полюбоваться всеми деталями, вот интересный обрезанный 512x512 (который не сжимается и отображается в полном размере):

введите описание изображения здесь

Спасибо githubphagocyte за идею. Это потребовало довольно сложного злоупотребления всеми тремя функциями цвета:

unsigned short RD(int i,int j){
    #define f(a,b)for(a=0;++a<b;)
    #define D float x=0,y=0
    static int z,m,n;if(!z){z=1;f(m,4096)f(n,4096)BL(m-4096,n-4096);};return GR(i,j);
}
unsigned short GR(int i,int j){
    #define R a=x*x-y*y+i/1024.+2;y=2*x*y+j/1024.+2
    static float c[DIM][DIM],p;if(i>=0)return(p=c[i][j])>DM1?DM1:p;c[j+DIM][i/2+DIM]+=i%2*2+1;
}
unsigned short BL(int i,int j){
    D,a,k,p=0;if(i<0)f(k,5e5){R;x=a;if(x*x>4||y*y>4)break;GR(int((x-2)*256)*2-p,(y-2)*256);if(!p&&k==5e5-1){x=y=k=0;p=1;}}else{return GR(i,j);}
}

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

Приведенный код использует исходные точки 4096x4096 и выполняет до 500 000 итераций на каждой из них, чтобы определить, удаляются или нет траектории. Это заняло от 6 до 7 часов на моей машине. Вы можете получить приличные результаты с сеткой 2k на 2k и итерациями 10k, что занимает две минуты, и даже просто сетка 1k на 1k с итерациями 1k выглядит довольно хорошо (это занимает около 3 секунд). Если вы хотите поиграть с этими параметрами, есть несколько мест, которые нужно изменить:

  • Чтобы изменить глубину рекурсии Мандельброта, настройте оба экземпляра 5e5in BLна свое количество итераций.
  • Чтобы изменить разрешение сетки, изменить все четыре 4096в RDдо нужного разрешения и 1024.ин GRна тот же фактор для поддержания правильного масштабирования.
  • Вы, вероятно , также необходимо масштабировать return c[i][j]в систему GRтак , что содержит только абсолютное число посещений каждого пикселя. Максимальный цвет, по-видимому, в основном не зависит от количества итераций и линейно масштабируется с общим числом начальных точек. Поэтому, если вы хотите использовать сетку 1 к 1, вы можете захотеть использовать ее return c[i][j]*16;или подобную, но этот фактор иногда требует некоторых усилий.

Для тех, кто не знаком с Буддхабротом (как и я пару дней назад), он основан на вычислении Мандельброта, но интенсивность каждого пикселя - это то, как часто этот пиксель посещался на итерациях траекторий ухода. Если мы подсчитываем посещения во время неходовых траекторий, то это Антибуддхаброт. Существует еще более сложная версия под названием Nebulabrot, в которой вы используете различную глубину рекурсии для каждого цветового канала. Но я оставлю это кому-то еще. Для получения дополнительной информации, как всегда, Википедия .

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

unsigned short RD(int i,int j){
    #define f(a)for(a=0;++a<DIM;)
    static int z;float x=0,y=0,m,n,k;if(!z){z=1;f(m)f(n)GR(m-DIM,n-DIM);};return BL(i,j);
}
unsigned short GR(int i,int j){
    float x=0,y=0,a,k;if(i<0)f(k){a=x*x-y*y+(i+256.0)/512;y=2*x*y+(j+512.0)/512;x=a;if(x*x+y*y>4)break;BL((x-.6)*512,(y-1)*512);}return BL(i,j);
}
unsigned short BL(int i,int j){
    static float c[DIM][DIM];if(i<0&&i>-DIM-1&&j<0&&j>-DIM-1)c[j+DIM][i+DIM]++;else if(i>0&&i<DIM&&j>0&&j<DIM)return log(c[i][j])*110;
}

введите описание изображения здесь

Этот выглядит немного как выцветшая фотография ... Мне это нравится.


8
Я сделаю это в шляпе.
cjfaure

6
Я действительно удивлен, что вы сократили это до 3 лотов по 140 байт. Новое изображение buddabrot прекрасно.
трихоплакс

4
Это действительно впечатляет.
copumpkin

Первый действительно хитрый. Напоминает мне медуз. +1
Игби Крупный человек

1
Это мое любимое представление. Хорошо сделано!
Томаллен

76

Серпинский Пентагон

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

unsigned char RD(int i,int j){
#define A int x=0,y=0,p[10]={512,9,0,381,196,981,827,981,DM1,381}
auto s=99./(j+99);return GR(i,j)?0:abs(53-int((3e3-i)*s+j*s)%107);}

unsigned char GR(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<2e7;n++){int v=(rand()%11+1)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

unsigned char BL(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<3e7;n++){int v=(rand()%11+4)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

Спасибо Мартину Бюттнеру за идею, упомянутую в комментариях к вопросу об определении макроса в одной функции для последующего использования в другой, а также за использование запоминания для заполнения пикселей в произвольном порядке, а не ограничения растровым порядком основной функции. ,

пятиугольник

Размер изображения превышает 500 КБ, поэтому он автоматически преобразуется в формат jpg путем замены стека. Это размывает некоторые мелкие детали, поэтому я также включил верхнюю правую четверть в виде png, чтобы показать оригинальный вид:

в правом верхнем углу


73

Ноты

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

Ноты

unsigned short RD(int i,int j){
    return ((int)(100*sin((i+400)*(j+100)/11115)))&i;
}
unsigned short GR(int i,int j){
    return RD(i,j);
}
unsigned short BL(int i,int j){
    return RD(i,j);
}

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

return ((int)(100*sin((i+400)*(j+100)/11115.0)));

усечение удаляется, и мы получаем рендер с полным разрешением:

Неблокированные ноты

Так что да, это интересно.


1
Это как Squarepusher, переписанный в neums
брезгливый

1
@squeamishossifrage Что я только что посмотрел ...?
cjfaure

:-) видео Криса Каннингема является немного странно, не так ли?
брезгливое оссифраж

14
второй выглядит так, как будто он движется, когда я прокручиваю страницу
user13267

5
При прокрутке сайта последний действительно двигался. Хорошая оптическая иллюзия.
Кайл Канос

61

Генератор случайных диаграмм Вороного кто-нибудь?

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

введите описание изображения здесь

Редактировать:

введите описание изображения здесь

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

Код

ungolfed, прокомментированная версия в конце

unsigned short red_fn(int i, int j){
int t[64],k=0,l,e,d=2e7;srand(time(0));while(k<64){t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short green_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short blue_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

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

Первый шаг: расположить несколько точек случайным образом, с x=y

введите описание изображения здесь

Я преобразовал его в jpeg, потому что исходный png был слишком тяжел для загрузки ( >2MB), я уверен, что это более 50 оттенков серого!

Второе: иметь лучшую координату у

Я не мог позволить себе создать другую таблицу координат, случайно сгенерированную для yоси, поэтому мне нужен был простой способ получить " случайные " из как можно меньшего числа символов. Я использовал xкоординату другой точки в таблице, выполнив побитовое ANDуправление индексом точки.

введите описание изображения здесь

3-е: я не помню, но становится лучше

Но в то время у меня было более 140 символов, поэтому мне нужно было немного упасть.

введите описание изображения здесь

4-е: сканы

Шучу, это не нужно, но круто, я думаю.

введите описание изображения здесь введите описание изображения здесь

Продолжая работать над уменьшением размера алгоритма, я с гордостью представляю:

Издание StarFox

введите описание изображения здесь

Вороной Инстаграм

введите описание изображения здесь

5-е: увеличить количество очков

Теперь у меня есть рабочий кусок кода, так что давайте перейдем от 25 до 60 баллов. введите описание изображения здесь

Это трудно увидеть только с одного изображения, но почти все точки находятся в одном yдиапазоне. Конечно, я не менял побитовую операцию, &42гораздо лучше:

введите описание изображения здесь

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

Разоблаченный и объясненный код

unsigned short red_fn(int i, int j)
{
    int t[64],          // table of 64 points's x coordinate
        k = 0,          // used for loops
        l,              // retains the index of the nearest point
        e,              // for intermediary results
        d = 2e7;        // d is the minimum distance to the (i,j) pixel encoutnered so far
        // it is initially set to 2e7=2'000'000 to be greater than the maximum distance 1024²

    srand(time(0));     // seed for random based on time of run
    // if the run overlaps two seconds, a split will be observed on the red diagram but that is
    // the better compromise I found

    while(k < 64)       // for every point
    {
        t[k] = rand() % DIM;        // assign it a random x coordinate in [0, 1023] range
        // this is done at each call unfortunately because static keyword and srand(...)
        // were mutually exclusive, lenght-wise

        if (
            (e=                         // assign the distance between pixel (i,j) and point of index k
                _sq(i - t[k])           // first part of the euclidian distance
                +
                _sq(j - t[42 & k++])    // second part, but this is the trick to have "" random "" y coordinates
                // instead of having another table to generate and look at, this uses the x coordinate of another point
                // 42 is 101010 in binary, which is a better pattern to apply a & on; it doesn't use all the table
                // I could have used 42^k to have a bijection k <-> 42^k but this creates a very visible pattern splitting the image at the diagonal
                // this also post-increments k for the while loop
            ) < d                       // chekcs if the distance we just calculated is lower than the minimal one we knew
        )
        // {                            // if that is the case
            d=e,                        // update the minimal distance
            l=k;                        // retain the index of the point for this distance
            // the comma ',' here is a trick to have multiple expressions in a single statement
            // and therefore avoiding the curly braces for the if
        // }
    }

    return t[l];        // finally, return the x coordinate of the nearest point
    // wait, what ? well, the different areas around points need to have a
    // "" random "" color too, and this does the trick without adding any variables
}

// The general idea is the same so I will only comment the differences from green_fn
unsigned short green_fn(int i, int j)
{
    static int t[64];       // we don't need to bother a srand() call, so we can have these points
    // static and generate their coordinates only once without adding too much characters
    // in C++, objects with static storage are initialized to 0
    // the table is therefore filled with 60 zeros
    // see http://stackoverflow.com/a/201116/1119972

    int k = 0, l, e, d = 2e7;

    while(k<64)
    {
        if( !t[k] )                 // this checks if the value at index k is equal to 0 or not
        // the negation of 0 will cast to true, and any other number to false
            t[k] = rand() % DIM;    // assign it a random x coordinate

        // the following is identical to red_fn
        if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)
            d=e,l=k;
    }

    return t[l];
}

Спасибо за чтение до сих пор.


1
Я люблю диаграммы Вороного. +1 за размещение в 3 твиттах!
Мартин Эндер

1
Это один из моих любимых. Варианты линии сканирования очень эстетичны.
Fraxtil

1
Люблю, как ты объяснил код
Андреа

Сделать прыжок в сед и отскок с поворотом на 360 град в сед!
Старсон Хохшильд

вторая картинка в 4-м: сканы прекрасны.
Халед.К

57

Фрактал Ляпунова

Ляпунов Фрактал

Строка, использованная для генерации этого, была AABAB, а пространство параметров было [2,4] x [2,4]. ( объяснение строки и пространства параметров здесь )

С ограниченным пространством кода я думал, что эта раскраска была довольно крутой.

    //RED
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s);
    //GREEN
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return s>0?s:0;
    //BLUE
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s*x);

Я также сделал вариацию множества Мандельброта. Он использует карту, аналогичную карте множеств Мандельброта. Скажем, M (x, y) - отображение Мандельброта. Тогда M (sin (x), cos (y)) - это карта, которую я использую, и вместо проверки на экранирование значений я использую x и y, поскольку они всегда ограничены.

//RED
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 2.5*(x*x+y*y);
//GREEN
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(x);
//BLUE
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(y);

введите описание изображения здесь

РЕДАКТИРОВАТЬ

После долгих болей я наконец-то нашел время для создания GIF-изображения второго изображения. Вот:

Время веселиться


11
Хороший психоделический взгляд для второго.
Интернет сделан из

4
Это безумие ! +1
cjfaure

10
Страшный фрактал страшный ༼ ༎ ຶ ෴ ༎ ຶ ༽
Тобия

1
Святое дерьмо, что второй страшно. Удивительно, сколько вы можете получить из простого z = z ^ 2 + c.
Томсминг

4
Если бы Эдвард Мунк рисовал фракталы, это было бы так, как выглядел Крик .
Интернет сделан из catz

55

Потому что единороги.

Потому что единороги

Я не смог получить версию OP с unsigned shortработающими значениями цвета до 1023, так что пока это не исправлено, здесь используется версия charи максимальное значение цвета 255.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}

Я хотел бы видеть цветные каналы индивидуально. Было бы здорово.
хлопнуть

52

Logistic Hills

введите описание изображения здесь

Функции

unsigned char RD(int i,int j){    
    #define A float a=0,b,k,r,x
    #define B int e,o
    #define C(x) x>255?255:x
    #define R return
    #define D DIM
    R BL(i,j)*(D-i)/D;
}
unsigned char GR(int i,int j){      
    #define E DM1
    #define F static float
    #define G for(
    #define H r=a*1.6/D+2.4;x=1.0001*b/D
    R BL(i,j)*(D-j/2)/D;
}
unsigned char BL(int i,int j){
    F c[D][D];if(i+j<1){A;B;G;a<D;a+=0.1){G b=0;b<D;b++){H;G k=0;k<D;k++){x=r*x*(1-x);if(k>D/2){e=a;o=(E*x);c[e][o]+=0.01;}}}}}R C(c[j][i])*i/D;
}

Ungolfed

Все #defines должны соответствовать BL до 140 символов. Вот немного измененная версия синего алгоритма:

for(double a=0;a<DIM;a+=0.1){       // Incrementing a by 1 will miss points
    for(int b=0;b<DIM;b++){         // 1024 here is arbitrary, but convenient
        double r = a*(1.6/DIM)+2.4; // This is the r in the logistic bifurcation diagram (x axis)
        double x = 1.0001*b/DIM;    // This is x in the logistic bifurcation diagram (y axis). The 1.0001 is because nice fractions can lead to pathological behavior.
        for(int k=0;k<DIM;k++){
            x = r*x*(1-x);          // Apply the logistic map to x
            // We do this DIM/2 times without recording anything, just to get x out of unstable values
            if(k>DIM/2){
                if(c[(int)a][(int)(DM1*x)]<255){
                    c[(int)a][(int)(DM1*x)]+=0.01; // x makes a mark in c[][]
                } // In the golfed code, I just always add 0.01 here, and clip c to 255
            }
        }            
    }    
}

В тех случаях, когда значения x падают наиболее часто для данного значения r (j), график становится светлее (обычно изображается темнее).


3
Ой, я думал о том, как сделать это вчера. +1 для выяснения этого. Я действительно считаю, что палитра действительно хороша! :)
Мартин Эндер

2
Я украл грязные уловки у тебя и гитхфагоцитов, хотя я беру на себя ответственность за уродливые #defines. Особенно "#define G for (".
Эрик Тресслер

1
больше похоже на визуализатор турнирной сетки
Кевин Л

3
Не изображено сверху: победитель умирает
Эрик Тресслер

1
Могу ли я получить печать размером с плакат? С 3 выцветшими твитами на заднем плане. :-)
Эндрю Чонг

50

Диффузионная ограниченная агрегация

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

Мне было трудно написать это всего лишь 140 символами на функцию, поэтому мне пришлось сделать код ужасным (или красивым, если вам нравятся такие вещи, как ++d%=4и for(n=1;n;n++)). Три цветовые функции вызывают друг друга и определяют макросы для использования, поэтому они не читаются хорошо, но каждая функция имеет длину до 140 символов.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-(BL(i,j))/2:0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

диффузионно-ограниченная агрегация

Чтобы визуализировать, как частицы постепенно агрегируют, я делал снимки через равные промежутки времени. Каждый кадр был произведен путем замены 1 в for(n=1;n;n++)0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Это держало его под пределом в 140 символов для каждого запуска.

анимированная агрегация

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


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

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-BL(i,j):0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

DLA с видимыми частицами

Это может быть анимировано так же, как и раньше:

анимированная агрегация с частицами


3
Очень интересно, +1.
интернет сделан из catz

50

Спираль (точно 140)

конечный продукт

Это 140 символов точно, если вы не включаете заголовки функций и скобки. Это такая сложная спираль, которую я мог бы уместить в характере персонажа.

unsigned char RD(int i,int j){
    return DIM-BL(2*i,2*j);
}
unsigned char GR(int i,int j){
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    i-=512;j-=512;int d=sqrt(i*i+j*j);return d+atan2(j,i)*82+sin(_cr(d*d))*32+sin(atan2(j,i)*10)*64;
}

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

unsigned char RD(int i,int j){
    // *2 expand the spiral
    // DIM- reverse the gradient
    return DIM - BL(2*i, 2*j);
}
unsigned char GR(int i,int j){
    // notice swapped parameters
    // 128 changes phase of the spiral
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    // center it
    i -= DIM / 2;
    j -= DIM / 2;

    double theta = atan2(j,i); //angle that point is from center
    double prc = theta / 3.14f / 2.0f; // percent around the circle

    int dist = sqrt(i*i + j*j); // distance from center

    // EDIT: if you change this to something like "prc * n * 256" where n
    //   is an integer, the spirals will line up for any arbitrarily sized
    //   DIM value, or if you make separate DIMX and DIMY values!
    int makeSpiral = prc * DIM / 2;

    // makes pattern on edge of the spiral
    int waves = sin(_cr(dist * dist)) * 32 + sin(theta * 10) * 64;

    return dist + makeSpiral + waves;
}

Возиться с параметрами:

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

края

Здесь градиент был удален:

нет градиента

Анимация ( которая по какой-то причине не выглядит зацикленной после того, как я ее загрузил, извините. Кроме того, мне пришлось уменьшить ее. Просто откройте ее на новой вкладке, если вы пропустили анимацию ):

анимация

И вот альбом imgur со всеми изображениями в нем. Я хотел бы посмотреть, сможет ли кто-нибудь найти другие крутые спиральные узоры. Кроме того, я должен сказать, что это одна из самых крутых проблем, которые я когда-либо видел. Наслаждайтесь!

РЕДАКТИРОВАТЬ: Вот некоторые фоны, сделанные из этих спиралей с измененными параметрами.

Кроме того, объединяя мои спиральные узоры с некоторыми из фракталов, которые я видел здесь с помощью операций xor / и / или, мы получаем заключительную спираль:

фрактальная спираль


2
Это фантастика! Если вы посмотрите на другие ответы, вы сможете найти идеи, которые помогут вам в этом еще глубже, если вы хотите больше места. В нескольких ответах используется #define в одной функции для определения макроса, который могут использовать все 3, так что вы можете перенести большую часть вычислений в другие цветовые функции. Мартин Бюттнер познакомил меня с этим трюком.
Трихоплакс

Спасибо! В моем случае, насколько я могу судить, в моем коде отсутствует тип дублирующих логических шаблонов, которые могли бы получить преимущества от определений фунта. Однако, если вы видите что-либо, я был бы признателен, если бы вы определили их мне, особенно если бы я не использовал C / C ++ в течение многих лет.
xleviator

Поиск дублирующих разделов действительно поможет еще больше, но даже без дублирования вы можете просто переместить код из BL в RD или GN, определив его как макрос в RD или GN, а затем использовать его в BL. Это должно дать вам вдвое больше места для дополнительного кода.
трихоплакс,

Ах! Понимаю. Я даже не осознавал, что каждое тело функции имеет ограничение в 140 символов. Я полагаю, что в следующий раз я должен прочитать подсказку более внимательно. Спасибо, что указали на это!
xleviator

1
Как уже говорилось в чате , ваш не зацикленный GIF должен быть легко исправим. Я думаю, что это стоит сделать, так как короткая анимация, которую он сейчас показывает, выглядит великолепно.
трихоплакс

47

Дань классика

V1 : Вдохновленный DreamWarrior «Будь счастлив», это прямое представление встраивает небольшое пиксельное изображение в каждый цветовой канал. Мне даже не нужно было играть в гольф код!
V2 : теперь со значительно более коротким кодом и толстой черной рамкой, изолирующей только «игровой экран».
V3 : космический корабль, пуля, поврежденные инопланетяне и синяя рамка, о боже! Попытка приблизиться к этому , примерно.

// RED
#define g(I,S,W,M)j/128%8==I&W>>(j/32%4*16+i/64)%M&S[abs(i/4%16-8)-(I%2&i%64<32)]>>j/4%8&1
return g(1,"_\xB6\\\x98\0\0\0",255L<<36,64)?j:0;

// GREEN
#define S g(6,"\xFF\xFE\xF8\xF8\xF8\xF8\xF0\x0",1L<<22,64)|i/4==104&j/24==30
return g(2,"<\xBC\xB6}\30p\0\0",4080,32)|S?j:0;

// BLUE
return g(3,"_7\xB6\xFE\x5E\34\0",0x70000000FD0,64)|S|abs(i/4-128)==80&abs(j/4-128)<96|abs(j/4-128)==96&abs(i/4-128)<80?j:0;

Космические захватчики


Я случайно наткнулся на правку Убер Ферруле, чей аватар вдохновил меня на добавление еще одной записи, основанной на пиксельной графике. Поскольку основная идея кода во многом похожа на идею Space Invaders, я добавляю ее к этой записи, хотя у этих двух определенно были разные сложные моменты. Для этого получить розовый цвет правильно (за счет белого) и тот факт, что это довольно большой спрайт, оказалось хорошим испытанием. Шестнадцатеричные экранированные \xFFсимволы (и т. Д.) В красном канале представляют соответствующие им символы в исходном файле (то есть красный канал в исходном файле содержит двоичные данные), тогда как восьмеричные экранирующие переменные являются литеральными (то есть присутствуют в исходном файле).

// RED
#define g(S)(S[i/29%18*2+j/29/8%2]>>j/29%8&1)*DM1*(abs(i-512)<247&abs(j-464)<232)
return g("\xF3\xF2\xF2\x10\xF4\0\xF2\x10\xE1\xE0\x81\0\x80\0\x80\0\0\0\0\0@\0! \x03d8,=\x2C\x99\x84\xC3\x82\xE1\xE3");

// GREEN
return g(";\376z\34\377\374\372\30k\360\3\200\0\0\0\0\0\0\200\0\300\0\341 \373d\307\354\303\374e\374;\376;\377")? DM1 : BL(i,j)? DM1/2 : 0;

// BLUE
return g("\363\360\362\20\364\0\362\20\341\340\200\0\200\0\200\0\0\0\0\0\0\0\0\0\0\08\0<\0\230\0\300\0\341\340") / 2;

Bub (Bubble Bobble)


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

1
Да, есть много хитростей, чтобы уменьшить размер. Я мог бы попробовать продлить его завтра.
FireFly

Это невероятно коротко сейчас. Не могли бы вы вписать один из этих битовых шаблонов в текстуру в своем ответе по радиопередаче ...?
Трихоплакс,

@ MartinBüttner ой, ты прав. Я исправил это и сделал еще одно обновление функций.
FireFly

Аккуратно, мне нравится, как вы взяли пиксельную графику 8х8 и «изменили ее размер» на лету. Тем не менее, мне пришлось внести несколько изменений, и я до сих пор не могу получить именно ваше изображение. Я изменил 1L и 255L на 1LL и 255LL. Поскольку это улучшило ситуацию, я предполагаю, что вы, вероятно, компилируете в 64-битном режиме, и есть некоторые проблемы с шириной в битах, из-за которых остальная часть моего изображения получается неправильной. Но, тем не менее, хорошая работа!
DreamWarrior

44

Живопись действия

Я хотел попробовать воссоздать что-то похожее на работу Джексона Поллока - капать и поливать краской горизонтальный холст. Хотя результаты мне понравились, код был слишком длинным, чтобы публиковать ответы на этот вопрос, и мои лучшие усилия все же сократили его до 600 байтов. Таким образом, код, размещенный здесь (который имеет функции 139 байтов, 140 байтов и 140 байтов соответственно), был создан с огромной помощью некоторых гениев в чате . Огромное спасибо:

для неумолимой групповой игры в гольф.

unsigned char RD(int i,int j){
#define E(q)return i+j?T-((T-BL(i,j))*q):T;
#define T 255
#define R .1*(rand()%11)
#define M(v)(v>0&v<DIM)*int(v)
#define J [j]*250;
E(21)}

unsigned char GR(int i,int j){
#define S DIM][DIM],n=1e3,r,a,s,c,x,y,d=.1,e,f;for(;i+j<1&&n--;x=R*DM1,y=R*DM1,s=R*R*R*R,a=R*7,r=s*T)for(c=R;r>1;x+=s*cos(a),y+=s*sin
E(21)}

unsigned char BL(int i,int j){static float m[S(a),d=rand()%39?d:-d,a+=d*R,s*=1+R/99,r*=.998)for(e=-r;e++<r;)for(f=-r;f++<r;)m[M(x+e)*(e*e+f*f<r)][M(y+f)]=c;return T-m[i]J}

боевик 21, 21

Макрос E (q) используется в функциях RD и GR. Изменение значения аргумента изменяет способ изменения красного и зеленого компонентов цветов. Макрос J заканчивается числом, которое используется для определения степени изменения синего компонента, который, в свою очередь, влияет на красный и зеленый компоненты, поскольку они рассчитываются по нему. Я включил некоторые изображения с красными и зелеными аргументами E, чтобы показать разнообразие возможных цветовых комбинаций. Наведите указатель мыши на изображения для красного и зеленого значений, если вы хотите запустить их самостоятельно.

боевик 14, 14

боевик 63, 49

экшн-живопись 56, 42

боевик 0, 49

Все эти изображения можно просмотреть в полном размере, если вы загрузите их. Размер файла невелик, поскольку плоский цвет соответствует алгоритму сжатия PNG, поэтому для загрузки на сайт сжатие с потерями не требовалось.

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


7
Я слежу за этим вопросом и за всеми ответами уже пару недель, и должен сказать, что это первый раз, когда моя челюсть действительно упала. СВЯТОЕ ИЗУМИТЕЛЬНОЕ. Я имею в виду, что все ответы здесь великолепны, но этот - то, чего я никогда не ожидал.
Тодд Леман

1
@ ToddLehman спасибо! Это, конечно, не то, на что я был бы способен в одиночку - я знаю, потому что пытался ...
trichoplax

2
КЛАССНО! Один из лучших в этом вопросе и для меня единственный (возможно, кроме победителя), который выглядит как
нарисованный

1
@cyriel большое спасибо. Можно сказать, что это было нарисовано 5 людьми ...
trichoplax

43

Думаю, я бы поигрался с параметрами этого кода ... Все заслуги достаются @Manuel Kasten. Это так круто, что я не устоял перед публикацией. Горячий холодный

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 1000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);

BubbleGumRupture http://i57.tinypic.com/3150eqa.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 40*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 10*pow((n)/800,.5);

SeussZoom http://i59.tinypic.com/am3ypi.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 4000*pow((n)/800,.5);

SeussEternalForest http://i61.tinypic.com/35akv91.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);

3
Похоже, доктор Сьюз для меня. Очень круто!
DLosc

3
Ха-ха, я фактически назвал два нижних файла Seuss1 и Sueuss2
Кайл Маккормик,

42

Изменить: теперь это правильный ответ, благодаря предварительным декларациям GRи BL.

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

введите описание изображения здесь

Последовательность очень похожа на последовательность Фибоначчи, но вместо того, чтобы вернуться назад в последовательности на 1 и 2 шага, вы берете два предыдущих значения, чтобы определить, как далеко нужно вернуться, прежде чем брать сумму. Он растет примерно линейно, но время от времени возникает взрыв хаоса (с увеличивающимися интервалами), который затем снова сводится к почти линейной последовательности перед следующим всплеском:

введите описание изображения здесь

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

Конечно, использование только одного цвета скучно.

введите описание изображения здесь

Теперь для кода. Мне нужна рекурсивная функция для вычисления последовательности. Для этого я использую RDвсякий раз, когда jотрицательно. К сожалению, это не оставляет достаточного количества символов для вычисления самого значения красного канала, поэтому RDв свою очередь вызывает GRсо смещением для получения красного канала.

unsigned short RD(int i,int j){
    static int h[1000];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):GR(i+256,j+512);
}
unsigned short GR(int i,int j){
    return DIM-4*RD(sqrt((i-512)*(i-512)+(j-768)*(j-768))/2.9,-1);
}
unsigned short BL(int i,int j){
    return DIM-4*RD(sqrt((i-768)*(i-768)+(j-256)*(j-256))/2.9,-1);
}

Конечно, это в значительной степени простейшее возможное использование последовательности, и осталось множество символов. Не стесняйтесь заимствовать это и делать другие сумасшедшие вещи с этим!

Вот еще одна версия, где граница и цвета определяются Q-последовательностью. В этом случае места было достаточно, RDчтобы мне даже не понадобилось предварительное объявление:

unsigned short RD(int i,int j){
    static int h[1024];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):RD(2*RD(i,-1)-i+512>1023-j?i:1023-i,-1)/0.6;
}
unsigned short GR(int i,int j){
    return RD(i, j);
}
unsigned short BL(int i,int j){
    return RD(i, j);
}

введите описание изображения здесь


1
Это второе серое изображение ошеломляет!
Томсминг

Можете ли вы компактифицировать это достаточно для того, чтобы рекурсивно использовать сами функции r / g / b с неверными координатами для рекурсивных вызовов?
Спарр

Я любил многоцветное изображение. Хороший ответ!
Алекс

41

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

unsigned short RD(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s,n=hypot(r+(.866-r/2)/q,s+(r*.866+s/2)/q),
    d=.5/log(n);if(d<0||d>1)d=1;return d*(sin(n*10)*511+512);
}
unsigned short GR(int i,int j){
    return 0;
}
unsigned short BL(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s;return RD(i,j)*sqrt(q/40);
}

введите описание изображения здесь


39

Objective-C

Переписал код C ++ в Objective-C, потому что я не смог его скомпилировать ... Он дал те же результаты, что и другие ответы при работе на моем iPad, так что это все хорошо.

Вот мое представление:

Треугольники в изобилии

Код этого довольно прост:

unsigned short red_fn(int i,int j)
{
    return j^j-i^i;
}
unsigned short green_fn(int i,int j)
{
    return (i-DIM)^2+(j-DIM)^2;
}
unsigned short blue_fn(int i,int j)
{
    return i^i-j^j;
}

Вы можете увеличить на площадях путем умножения iи jна 0.5, и 0.25т.д. , прежде чем они будут обработаны.


Вы уверены, что это тот же код, который вы использовали? ^ Выглядит немного странно, потому что (i ^ i) всегда равно 0 (XOR), а ^ 2 больше напоминает квадрат, чем бит XOR.
Мануэль Феррерия

1
@ManuelFerreria С XOR код на самом деле скомпилирован так: x^(x-y)^y(это меня тоже смутило в первый раз). Если у вас есть возможности iOS, вот мой код: gist.github.com/Jugale/28df46f87037d81d2a8f
Макс Чукимия

38

Всплеск краски Серпинского

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

Всплеск краски Серпинского

unsigned short RD(int i,int j){
    return(sqrt(_sq(abs(73.-i))+_sq(abs(609.-j)))+1.)/abs(sin((sqrt(_sq(abs(860.-i))+_sq(abs(162.-j))))/115.)+2)/(115^i&j);
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(abs(160.-i))+_sq(abs(60.-j)))+1.)/abs(sin((sqrt(_sq(abs(73.-i))+_sq(abs(609.-j))))/115.)+2)/(115^i&j);
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(abs(600.-i))+_sq(abs(259.-j)))+1.)/abs(sin((sqrt(_sq(abs(250.-i))+_sq(abs(20.-j))))/115.)+2)/(115^i&j);
}

Теперь это мой аватар. :П


4
Отличная работа. сэр, хорошая работа.
EaterOfCode

37

Я чувствую себя обязанным представить эту запись, которую я назову «неопределенным поведением», которая проиллюстрирует, что ваш компилятор делает с функциями, которые должны возвращать значение, но не:

unsigned short red_fn(int i,int j){}
unsigned short green_fn(int i,int j){}
unsigned short blue_fn(int i,int j){}

Все черные пиксели:

все черные пиксели

Псевдослучайные пиксели:

псевдослучайные пиксели

И, конечно же, множество других возможных результатов в зависимости от вашего компилятора, компьютера, менеджера памяти и т. Д.


3
Что вы получили?
Томсминг

3
Я получил сплошной черный и сплошной цвет, который менялся между разными запусками программы с разными компиляторами.
Спарр

8
Мой компилятор просто ошибается и кричит на меня за то, что я не вернул значение.
Pharap

3
@Pharap это не плохо :)
Спарр

Я сомневаюсь, что вы когда-нибудь получите такую ​​хорошую случайность, как подсказывает вторая картина Постоянное значение, индекс цикла и т. Д. Гораздо более вероятны (что хранится в EAX при вызове функции).
например,

37

заводной

groovy.png

Просто тригонометрия и странные макро-трюки.

RD:

#define I (i-512)
#define J (j-512)
#define A (sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

GR:

#undef A
#define A (M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

BL:

#undef A
#define A (2*M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

РЕДАКТИРОВАТЬ: если M_PIне разрешено только из-за присутствия в POSIX-совместимых системах, его можно заменить на литерал 3.14.


1
Если у вас есть запасные персонажи, acos(-1)это хорошая замена для M_PI.
Мартин Эндер

33

Я не очень хорош в математике. Я всегда был плохим учеником на уроке математики. Так что я сделал простой.

mathpic1.png

Я использовал модифицированный код Javascript user1455003 . И это мой полный код .

function red(x, y) {
    return (x + y) & y;
}

function green(x, y) {
    return (255 + x - y) & x;
}

function blue(x, y) {
    // looks like blue channel is useless
    return Math.pow(x, y) & y;
}

Он очень короткий, поэтому все три функции помещаются в один твит.


mathpic2.png

function red(x, y) {
    return Math.cos(x & y) << 16;
}

function green(x, y) {
    return red(DIM - x, DIM - y);
}

function blue(x, y) {
    return Math.tan(x ^ y) << 8;
}

Еще одна очень короткая функция. Я нашел этот паттерн Серпинского (и некоторый касательный паттерн), пока возился с различными математическими функциями. Это полный код


Просто i&jвизуализирует треугольник Серпинского. Который потрясающий .
cjfaure

Этот последний достойный аватар.
mbomb007

32

JavaScript

var can = document.createElement('canvas');
can.width=1024;
can.height=1024;
can.style.position='fixed';
can.style.left='0px';
can.style.top='0px';
can.onclick=function(){
  document.body.removeChild(can);
};

document.body.appendChild(can);

var ctx = can.getContext('2d');
var imageData = ctx.getImageData(0,0,1024,1024);
var data = imageData.data;
var x = 0, y = 0;
for (var i = 0, len = data.length; i < len;) {
    data[i++] = red(x, y) >> 2;
    data[i++] = green(x, y) >> 2;
    data[i++] = blue(x, y) >> 2;
    data[i++] = 255;
    if (++x === 1024) x=0, y++;
}
ctx.putImageData(imageData,0,0);

function red(x,y){
if(x>600||y>560) return 1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function green(x,y){
if(x>600||y>560) return y%160<80?0:1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:1024;
}

Соединенные Штаты Америки

Другая версия. Функциональные тела являются твиттерными.

function red(x,y){
c=x*y%1024
if(x>600||y>560) return c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function green(x,y){
c=x*y%1024
if(x>600||y>560) return y%160<80?0:c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:x*y%1024;
}

введите описание изображения здесь

Исправлена ​​функция рендеринга изображений. draw (rgbFunctions, setCloseEvent);

function draw(F,e){
    var D=document
    var c,id,d,x,y,i,L,s=1024,b=D.getElementsByTagName('body')[0]
    c=D.createElement('canvas').getContext('2d')
    if(e)c.canvas.onclick=function(){b.removeChild(c.canvas)}
    b.appendChild(c.canvas)
    c.canvas.width=c.canvas.height=s
    G=c.getImageData(0,0,s,s)
    d=G.data
    x=y=i=0;
    for (L=d.length;i<L;){
        d[i++]=F.r(x,y)>>2
        d[i++]=F.g(x,y)>>2
        d[i++]=F.b(x,y)>>2
        d[i++]=255;
        if(++x===s)x=0,y++
    }
    c.putImageData(G,0,0)
}

Фиолетовый

var purple = {
    r: function(i,j) {
        if (j < 512) j=1024-j
        return (i % j) | i
    },
    g: function(i,j){
        if (j < 512) j = 1024 -j
        return (1024-i ^ (i %j)) % j
    },
    b: function(i,j){
        if (j < 512) j = 1024 -j
        return 1024-i | i+j %512
    }
};

draw(purple,true);

введите описание изображения здесь


CHEATER! CHEATER! ; D (это правильный ответ, слишком умный: P Хороший!)
Томсминг

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

Вы можете сделать более мелкие цветные изображения немного богаче, добавив некоторый шум зернистости пленки в младшие биты, применив «| Math.random () * 256» к их концу. Делает более темные оттенки более случайным образом, не изменяя бликов. (и увеличивать число в зависимости от порога тьмы)
Кент Фредрик

случайность rgb @ [10,728,728] i.imgur.com/ms4Cuzo.png
Кент Фредрик

31

Планетарный художник

//red
static int r[DIM];int p=rand()%9-4;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//green
static int r[DIM];int p=rand()%7-3;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//blue
static int r[DIM];int p=rand()%15-7;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;

Вдохновленный явно потрясающей записью Мартина , это другой взгляд на это. Вместо случайного заполнения части пикселей я начинаю с верхнего левого угла как RGB (512,512,512), и оттуда беру случайные прогулки по каждому цвету. Результат выглядит как что-то из телескопа (IMO).

Каждый пиксель берет среднее значение пикселей над / слева от него и добавляет немного случайных. Вы можете играть с изменчивостью, изменяяp переменную, но я думаю, что я использую хороший баланс (в основном потому, что мне нравится синий, поэтому большая волатильность размытия дает хорошие результаты).

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

Конечно, чтобы получить больше, чем просто один результат, вам нужно добавить srand()строку в вашу основную функцию.

группы


2
Если бы изображение было немного больше, оно бы выглядело как лучи света. o:
cjfaure

1
@cjfaure, если вы просматриваете изображение в полном размере (загрузка / щелчок правой кнопкой мыши и просмотр изображения / все, что работает в вашей системе), то оно выглядит еще более красиво с дополнительными деталями.
Трихоплакс

сделайте его окруженным черным кругом, и это сделает планету!
Халед.К

1
Я попытался обернуть это вокруг сферы в блендере, и я сделал анимацию. Смотрите здесь: gfycat.com/SameAnotherDinosaur
starbeamrainbowlabs

30

Отраженные волны

unsigned char RD(int i,int j){
#define A static double w=8000,l,k,r,d,p,q,a,b,x,y;x=i;y=j;for(a=8;a+9;a--){for(b=8;b+9;b--){l=i-a*DIM-(int(a)%2?227:796);
return 0;}

unsigned char GR(int i,int j){
#define B k=j-b*DIM-(int(b)%2?417:606);r=sqrt(l*l+k*k);d=16*cos((r-w)/7)*exp(-_sq(r-w)/120);p=d*l/r;q=d*k/r;x-=p;y-=q;}}
return 0;}

unsigned char BL(int i,int j){AB
return (int(x/64)+int(y/64))%2*255;}

Основной рисунок шахматной доски, искаженный в соответствии с положением волны, расширяющейся из точки, подобной камню, упавшему в пруд (очень далеко от физической точности!). Переменная w- это количество пикселей от той точки, на которую переместилась волна. Если wон достаточно велик, волна отражается от сторон изображения.

w = 225

волны с ш = 225

w = 360

волны с w = 360

w = 5390

волны с ш = 5390

Вот GIF, показывающий последовательность изображений по мере расширения волны. Я предоставил несколько разных размеров, каждый из которых отображает столько кадров, сколько позволяет ограничение размера файла 500 КБ.

волны большой GIF

волны маленький GIF волны среднего GIF


Если бы я мог найти способ его вписать, то в идеале я бы хотел смоделировать волновые помехи, чтобы волны при пересечении выглядели более реалистичными. Я доволен отражением, хотя.

Обратите внимание, что я не смоделировал отражение волны в 3 лотах по 140 байт. На самом деле никакого отражения не происходит, просто так выглядит. Я спрятал объяснение на случай, если кто-то захочет сначала угадать:

Первая отраженная волна идентична волне, исходящей с другой стороны края изображения, на том же расстоянии, что и исходная точка. Таким образом, код вычисляет правильное положение для 4 точек, необходимых для получения эффекта отражения от каждого из 4 ребер. Дальнейшие уровни отраженной волны все идентичны волне, возникающей в более отдаленном фрагменте, если вы представляете изображение как один фрагмент в плоскости. Код дает иллюзию 8 уровней отражения, отображая 189 отдельных расширяющихся кругов, каждый из которых расположен в правильной точке сетки 17 на 17, так что они проходят через центральный квадрат сетки (то есть квадрат изображения) в самое подходящее время, чтобы создать впечатление необходимого текущего уровня отражения. Это простой (и короткий!) Код, но работает довольно медленно ...


3
Люблю гифки и объяснения.
DLosc

Neato! Но человек, такие записи заставляют меня думать, что мне нужен более быстрый компьютер (или больше терпения, смеется). Либо ваш компьютер работает намного быстрее, либо я не хочу думать, сколько времени у вас ушло на создание всех этих GIF-кадров.
DreamWarrior

3
@DreamWarrior Это не я терпеливый. Это мой ноутбук, который не прочь поработать всю ночь, пока я сплю ...
trichoplax

2
Я вижу Пакмана на втором изображении.
AL
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.