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

Ваш вызов

Напишите 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);

/* 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;

Правила

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

• Если эта версия не работает для вас, убедитесь, что вы компилируете с:

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

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

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

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

Мандельброт 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);
}

Скатерти

Плоский

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

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;}

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

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. (Не то чтобы такого не было, но все равно весело!)

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

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

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 указал, что на моих фотографиях есть Бэтмен.

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

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;
}

дает

Юлия сет

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

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

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

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;}

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

Это интересно, потому что в нем вообще не используются параметры 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;
}

/* 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);

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

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

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

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

Это слегка сжимается во время загрузки (и сокращается при встраивании), поэтому, если вы хотите полюбоваться всеми деталями, вот интересный обрезанный 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;
}

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

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

Возможно, вы видели игровой метод приближения треугольника Серпинского путем построения точек на полпути к случайно выбранной вершине. Здесь я применил тот же подход, используя 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, чтобы показать оригинальный вид:

Ноты

Музыка Серпинского. : 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)));

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

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

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

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

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

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

Код

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];
}

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

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

Строка, использованная для генерации этого, была 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-изображения второго изображения. Вот:

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

Я не смог получить версию 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);
}

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), график становится светлее (обычно изображается темнее).

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

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

Мне было трудно написать это всего лишь 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];}

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

Спираль (точно 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 / и / или, мы получаем заключительную спираль:

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

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;

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

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

• Эрик Тресслер
• Светлячок
• PhiNotPi
• Мартин Бюттнер

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

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}

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

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

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

Думаю, я бы поигрался с параметрами этого кода ... Все заслуги достаются @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);

Изменить: теперь это правильный ответ, благодаря предварительным декларациям 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);
}

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

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);
}

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т.д. , прежде чем они будут обработаны.

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

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

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);
}

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

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

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

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

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

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

заводной

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

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.

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

Я использовал модифицированный код 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;
}

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

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;
}

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

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);

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

//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()строку в вашу основную функцию.

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

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

w = 360

w = 5390

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

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

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

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