Математичне мистецтво із твітера [закрито]


330

Матеріальна цілість може генерувати дивовижні візерунки, коли викладаються по сітці. Навіть найпростіші функції можуть дати приголомшливо складні конструкції!

Ваше завдання

Напишіть 3 твітні (тобто 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 ++ , замініть свої функції. Я надав кілька макросів і включив бібліотеку, і ви можете включити комплекс.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 символів, я взяв трюки та оптимізацію цього рішення в шахту (дякую Мартіну і Тодду). Це залишило простір для вибору цікавого місця та масштабування, а також приємної кольорової теми:

mandelbrot

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 символи

mandelbrot-reduced

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

flat table cloth

Пульсація

Тоді я ввів пульсацію (не суворо правильну перспективу, але все ще на 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;
}

rippled table cloth

Колір

Потім я зробив деякі кольори більш дрібнозернистими, щоб надати детальнішу інформацію про ширший діапазон масштабів і зробити малюнок більш барвистим ...

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

coloured table cloth

В русі

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

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

animated table cloth


15
Це легендарно. (Y) Продовжуйте. : P
Мохаммед Аріб Сиддікі

Але як саме реалізується рух? У оригінальних рамках немає логіки зміни кадру, чи не так?
esteewhy

2
@esteewhy можна створювати лише нерухомі зображення. GIF показує послідовність нерухомих кадрів, кожен з яких був створений зміною значення після #define P. Це вимагало гольфу вниз, щоб дозволити додаткові символи для #define P 6.03.
трихоплакс

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

1
Я рекомендую сортувати відповіді за "найстарішими", і тоді ви можете побачити, як розвиваються нові підходи, як
з'являються

192

Випадковий художник

enter image description here

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 функції.

Тепер для деяких варіацій.

Пропускаючи пікселі, ми можемо зробити її трохи розмитішою.

enter image description here

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

enter image description here

Що мені потрібно з’ясувати:

  • З якихось причин я не можу вкластись 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];

щоб дати вам

enter image description here

Більше випадкових картин

Я трохи більше пограв з цим і створив деякі інші випадкові картини. Не все це можливо в межах цього виклику, тому я не хочу їх включати сюди. Але ви можете побачити їх у цій галереї imgur разом із деякими описами того, як я їх створив.

Я спокушаюсь розробити всі ці можливості в рамках і поставити це на GitHub. (Не те, щоб подібні речі ще не існували, але все одно весело!)


12
Я люблю таких. Я не розумів, що можна врахувати суміжні пікселі, не маючи доступу до даних пікселів - плавна робота!
трихоплакс

1
Мені дуже нагадує цей старий конкурс, коли правила полягали в тому, щоб вносити піксель кожного кольору в зображення.
Інтернети зроблені з Catz

2
Оце Так! Ці фотографії абсолютно красиві!
raptortech97

1
Класна галерея, радіальні акуратні.
Інтернети зроблені з Catz

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

162

Деякі чітко виражені речі

Так, я точно знав, як його назвати.

Some swirly pointy things

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

EDIT: Більше не використовується pow. EDIT 2: @PhiNotPi зазначив, що мені не потрібно так сильно використовувати abs.

Ви можете легко змінити опорні точки, щоб отримати іншу картину:

Some more swirly pointy things

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 зазначив, що в моїх фотографіях є Бетмен.

Batman


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

Звичайно, має бути подання Мандельброта.

enter image description here

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;

enter image description here

Згідно з пропозицією гітубфагоцитів та з удосконаленнями Тодда Лемана, ми можемо легко вибрати менші розділи:

Напр

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

дає

enter image description here


12
@tomsmeding Я повинен зізнатися, це вперше я реалізував набір Мандельброта.
Мартін Ендер

2
Настільки знаковим, як і повний набір Мандельброта (до речі, +1), схоже, що ви залишили собі достатньо місця для коригування параметрів та розміщення відповіді з деякими приголомшливо вивернутими деталями глибокого збільшення.
трихоплакс

1
@githubphagocyte Я вже думав про це, але ще не міг зайнятися перекомпіляцією та повторним перетворенням та перетворенням кожного разу, поки я не з'ясував гідних параметрів;). Можна зробити це пізніше. Спершу я повинен спробувати зовсім іншу функцію. ;)
Мартін Ендер

2
Нарешті, @githubphagocyte обійшов і додав це. дякую за пропозицію!
Мартін Ендер

2
Дякую @Todd, я оновив остаточну картинку з цим. Я використав 25600 ітерацій, що занадто довго. ;)
Мартін Ендер

110

Юлія встановлює

Якщо є Мандельброт, то має бути і Джулія.

enter image description here

Ви можете витратити години на коригування параметрів та функцій, тому це просто швидкий, який виглядає гідно.

Натхненний участю Мартіна.

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

Ви хочете трохи RNG?

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

У мене все одно не залишилося багато місця, тому мені довелося кинути червону Джулію, щоб поставити свої макроси і мати більш звичайний RNG ( timed насіння і справжній rand(), woohoo!).

enter image description here

Ну, щось не вистачає. Очевидно, що ці параметри повинні бути статичними, інакше у вас є дивні результати (але смішно, можливо, я вивчу трохи пізніше, якщо знайду щось цікаве).

Отже, ми маємо лише зелені та сині канали:

enter image description here

enter image description here

enter image description here

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

enter image description here

enter image description here

І нарешті новий код із випадковими параметрами:

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 (час (0) і rand ()? або просто час (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;
}

colorful


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

5
Він не повинен сильно змінюватися. (подвійний) rand () / RAND_MAX завжди повинен знаходитися в діапазоні [0,0, 1,0].
Мануель Кастен

2
Це один із моїх улюблених!
Захоплення Кальвіна

2
Це не тільки цікаво - це красиво!
Мартін Тома

104

Image

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



82

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

Редагувати: Це правильний Буддаброт зараз!

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

Я дуже хотів зупинитися після чотирьох ... але ...

enter image description here

Це злегка стискається під час завантаження (і зменшується після вбудовування), тому якщо ви хочете милуватися всіма деталями, ось цікавий обріз 512x512 (який не стискається і відображається в повному розмірі):

enter image description here

Завдяки 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 секунди). Якщо ви хочете познайомитися з цими параметрами, потрібно змінити кілька місць:

  • Щоб змінити глибину рекурсії Мандельброта, відрегулюйте обидва випадки 5e5вBL ваш підрахунок ітерацій.
  • Щоб змінити дозвіл сітки, змінити все чотири 4096в RDдо потрібного дозволу і 1024.інGR на той же фактор для підтримки правильного масштабування.
  • Ви, ймовірно , також необхідно масштабувати return c[i][j]в систему GRтак , що містить тільки абсолютне число відвідувань кожного пікселя. Здається, що максимальний колір здебільшого не залежить від кількості ітерацій та лінійно масштабується із загальною кількістю вихідних точок. Отже, якщо ви хочете використовувати сітку 1k на 1k, ви можете хотіти 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;
}

enter image description here

Цей трохи схожий на вицвілу фотографію ... Мені це подобається.


8
Я зроблю це в шапці.
cjfaure

6
Я по-справжньому здивований, що ви знизили це до 3-х лотів зі 140 байт. Новий образ буддаброда прекрасний.
трихоплакс

4
Це справді вражає.
капуста гарбуза

Перший справді майстерний. Нагадує мені про медуз. +1
Ігбі Ларгеман

1
Цей мій улюблений подання. Хороша робота!
thomallen

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 транскрибується в neumes
гидливо грифа

1
@squeamishossifrage Що я тільки дивився ...?
cjfaure

:-) відео Кріса Каннінгема є трохи дивно, чи не так?
писклива косточка

14
другий виглядає так, що він рухається, коли я прокручую сторінку
user13267

5
Прокручуючи сайт, останній, здавалося, рухався. Приємна оптична ілюзія.
Кайл Канос

61

Випадковий генератор діаграм Voronoi кому?

Гаразд, цей важкий час мені дав. Я думаю, що це досить приємно, навіть якщо результати не такі витончені, як деякі інші. Ось справа з випадковістю. Можливо, деякі проміжні зображення виглядають краще, але мені дуже хотілося мати повноцінний алгоритм роботи з діаграмами voronoi.

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

Редагувати:

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

Це один із прикладів підсумкового алгоритму. Зображення - це в основному суперпозиція трьох вороних діаграм, по одному на кожен кольоровий компонент (червоний, зелений, синій).

Код

неозорий, коментований варіант наприкінці

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 координату

Я не міг дозволити собі мати ще одну таблицю координат, випадково згенеровану для 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
Любіть, як ви пояснили код
Андреа

Робіть рулон бочки!
Starson Hochschild

другий малюнок у четвертому: сканування красиво.
Халед.К

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

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

EDIT

Після сильного болю я нарешті розібрався, щоб створити gif з другого зображення. Ось:

Час веселитися


11
Гарний психоделічний вигляд другого.
Інтернети зроблені з Catz

4
Це божевільні ! +1
cjfaure

10
Страшний фрактал страшно ༼ ༎ ຶ ෴ ༎ ຶ ༽
Tobia

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

4
Якби Едвард Мунк малював фрактали, так виглядав би Крик .
Інтернети зроблені з Catz

55

Тому що єдинороги.

Тому що єдинороги

Я не зміг отримати версію OPs із 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

Логістичні пагорби

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

Функції

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

Безумовно

Усі #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
Aww, я думав про те, як це зробити вчора. +1 для з'ясування. Я насправді річ, палітра справді приємна, як є! :)
Мартін Ендер

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

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

3
На фотографії не вгорі: помер переможець
Ерік Треслер

1
Чи можу я отримати відбиток розміру плаката? З трьома зів’ялими твітами на задньому плані. :-)
Ендрю Чонг

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;

Bubble Bobble


3
Я люблю це. Чимало місця для додаткових функцій ...
trichoplax

1
Так, є багато хитрощів, щоб зменшити розмір. Я б, можливо, поїхав би продовжити це завтра.
FireFly

Зараз це неймовірно мало. Не могли б ви вписати один із цих бітових візерунків у текстуру вашої відповіді на радіомовлення ...?
trichoplax

@ MartinBüttner на жаль, ви маєте рацію. Я виправив це і зробив ще одне оновлення функцій.
FireFly

Акуратно, мені подобається, як ти взяв мистецтво 8x8 пікселів і "змінив його" на ходу. Однак мені довелося внести кілька змін, і я все ще не отримую саме твого іміджу. Я змінив 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
Kyle McCormick

42

Редагувати: Тепер це правильна відповідь, завдяки попереднім заявам GRтаBL .

Весело з Q-послідовністю Hofstadter! Якщо ми використовуємо радіальну відстань від деякої точки як вхідний, а вихідний як зворотний колір, ми отримуємо щось, схоже на кольоровий вініл.

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

Послідовність дуже схожа на послідовність Фібоначчі, але замість того, щоб повторити 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
Це друге зображення сірого кольору приголомшливо!
tomsmeding

Чи можете ви зробити це досить компактним для того, щоб використовувати функції 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

Ціль-С

Переписав код 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
Max Chuquimia

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

Зараз це мій аватар. : P


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
Що ти отримав?
tomsmeding

3
Я отримав суцільний чорний і суцільний колір, який змінювався між різними програмами програми, з різними компіляторами.
Спарр

8
Мій компілятор просто помиляється і кричить на мене за те, що не повертає значення.
Фарап

3
@Pharap, це не погано :)
Sparr

Сумніваюся, у вас коли-небудь з'явиться така приємна випадковість, як це підказує ваша друга картина. Постійне значення, індекс циклу тощо набагато ймовірніші (що зберігається всередині 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;

EDIT: якщо 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;
}

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

Переглянута функція візуалізації зображення. нічия (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);

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


ЧЕТА! ЧЕТА! ; D (це
правдива

1
Ха-ха .. так, я знаю, тому я подав одну, що більше відповідає духу питання. Я насправді намагався робити візерунки і думав, що цікавлюсь, чи насправді можна щось намалювати.
вовчий молот

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

rgb randomness @ [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/SameAbodyDinosaur
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

хвилі з w = 225

w = 360

хвилі з w = 360

w = 5390

хвилі з w = 5390

Ось GIF, що показує послідовність зображень у міру розширення хвилі. Я надав кілька різних розмірів, кожен із яких показує стільки кадрів, скільки дозволить обмеження розміру файлу в 500 КБ.

хвилі великих GIF

хвилі невеликий GIF хвилі середній GIF


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

Зауважте, що я не дуже моделював відображення хвиль у 3 партіях 140 байт. Тут насправді не відбувається жодної рефлексії, це просто так виглядає. Я приховав пояснення, якщо хтось хоче спочатку здогадатися:

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


3
Любіть GIF і пояснення.
DLosc

Неато! Але людино, такі записи змушують мене думати, що мені потрібен швидший комп'ютер (або більше терпіння, хаха). Або ваш комп’ютер набагато швидше, або я не хочу думати, скільки часу вам знадобилося, щоб генерувати всі ці кадри GIF.
DreamWarrior

3
@DreamWarrior Терплячий не я. Це мій ноутбук, який не проти бігати протягом ночі, коли я сплю ...
trichoplax

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