# Reproduce an image using lines

Write a program that takes in a true-color RGB image I, the maximum number of lines to draw L, and the minimum m and maximum M length of each line. Output an image O that looks as much as possible like I and is drawn using L or fewer straight lines, all of which have Euclidean length between m and M.

Each line must be one solid color, have both endpoints in the bounds of O, and be drawn using Bresenham's line algorithm (which most graphics libraries will already do for you). Individual lines can only be 1-pixel thick.

All lines, even those of length 0, should take up at least one pixel. Lines may be drawn on top of one another.

Before drawing any lines you may initialize the background of O to any solid color (that may depend on I).

## Details

• O should have the same dimensions as I.
• L will always be a nonnegative integer. It may be greater than the area of I.
• m and M are nonnegative floating point numbers with M >= m. The distance between two pixels is the Euclidean distance between their centers. If this distance is less than m or greater than M, then a line between those pixels is not allowed.
• The lines should not be antialiased.
• Opacity and alpha should not be used.
• Your program should not take more than an hour to run on a decent modern computer on images with less than a million pixels and L less than 10,000.

## Test Images

You should of course show us your most accurate or interesting output images (which I expect will occur when L is between 5% and 25% of the number of pixels in I, and m and M are around one tenth of the diagonal size).

Here are some test images (click for originals). You may also post your own.

Simpler images:

This is a popularity contest. The highest voted submission wins.

## Notes

• It may be helpful to let L be derived from a percentage of total pixels in I as well as an absolute value. e.g. >>> imageliner I=img.png L=50% m=10 M=20 would be the same thing as >>> imageliner I=img.png L=32 m=10 M=20 if img.png were an 8 by 8 pixel image. Something similar could be done for m and M. This is not required.
• Since lines cannot go out of bounds, the longest lines possible will be the diagonal length of I. Having M higher than this should not break anything though.
• Naturally, if m is 0 and L is greater than or equal to the number of pixels in I, O could be identical to I by having length 0 "lines" at each pixel location. This behavior is not required.
• Arguably, reproducing the shape of I is more important than reproducing the color. You may want to look into edge detection.
• To clarify: Are libraries like SimpleCV allowed? And answers may have any choice for I, L, m, and M, including m=0 and L=area? – rationalis Aug 14 '14 at 7:03
• @epicwisdom Yes, all libraries (except things that already specifically do this task) are allowed. Feel free to use keypoints, edge detection, whatever. Your algorithm should work for any valid choices of I, L, m, M, include m = 0 and L = area. (Though of course, your algorithm may look better for particular tunings of the parameters.) – Calvin's Hobbies Aug 14 '14 at 7:11
• Then, for instance, this particular library algorithm would be considered an invalid answer? – rationalis Aug 14 '14 at 7:34
• @epicwisdom Actually I will allow that and other similar things. It looks like it'd still take some clever tweaking to make an image out of the lines it gives you. – Calvin's Hobbies Aug 14 '14 at 7:40
• Do lines need to have thickness 1? – aditsu quit because SE is EVIL Aug 17 '14 at 20:42

# C++ - somewhat random lines and then some

## First some random lines

The first step of the algorithm randomly generates lines, takes for the target image an average of the pixels along this, and then calculates if the summed up square of rgb space distances of all pixels would be lower if we would paint the new line (and only paint it, if it is). The new lines color for this is chosen as the channel wise average of the rgb values, with a -15/+15 random addition.

Things that I noticed and influenced the implementation:

• The initial color is the average of the complete image. This is to counter funny effects like when making it white, and the area is black, then already something as a bright green line is seen better, as it is nearer to black than the already white one.
• Taking the pure average color for the line is not so good as it turns out to be unable to generate highlights by being overwritten by later lines. Doing a little random deviation helps a bit, but if you look at starry night, it fails if the local contrast is high at many places.

I was experimenting with some numbers, and chose L=0.3*pixel_count(I) and left m=10 and M=50. It will produce nice results starting at around 0.25 to 0.26 for the number of lines, but I chose 0.3 to have more room for accurate details.

For the full sized golden gate image, this resulted in 235929 lines to paint (for which it took a whopping 13 seconds here). Note that all images here are displayed in reduced size and you need to open them in a new tab/download them to view the full resolution.

## Erase the unworthy

The next step is rather expensive (for the 235k lines it took about an hour, but that should be well within the "an hour for 10k lines on 1 megapixel" time requirement), but it is also a bit surprising. I go through all the previously painted lines, and remove those that do not make the image better. This leaves me in this run with only 97347 lines that produce the following image:

You probably need to download and compare them in an appropriate image viewer to spot most differences.

## and start over again

Now I have a lot of lines that I can paint again to have a total of 235929 again. Not much to say, so here is the image:

## short analysis

The whole procedure seems to work like a blurring filter that is sensitive to local contrast and object sizes. But it is also interesting to see where the lines are painted, so the program records these too (For each line, the pixel color will be made one step whiter, at the end the contrast is maximized). Here are the corresponding ones to the three colored above.

## animations

And since we all love animations, here are some animated gifs of the whole process for the smaller golden gate image. Note that there is significant dithering due to gif format (and since creators of true color animation file formats and browser manufacturers are in war over their egos, there is no standard format for true color animations, otherwise I could have added an .mng or similar).

## Some more

As requested, here are some results of the other images (again you might need to open them in a new tab to not have them downscaled)

## Future thoughts

Playing around with the code can give some intresting variations.

• Chose the color of the lines by random instead of being based on the average. You might need more than two cycles.
• The code in the pastebin also contains some idea of a genetic algorithm, but the image is probably already so good that it would take too many generations, and this code is also too slow to fit into the "one hour" rule.
• Do another round of erase/repaint, or even two...
• Change the limit of where lines can be erased (e.g. "must make the image at lest N better")

## The code

These are just the two main useful functions, the whole code doesn't fit in here and can be found at http://ideone.com/Z2P6Ls

The bmp classes raw and raw_line function do access pixels and lines respectively in an object that can be written to bmp format (It was just some hack lying around and I thought that makes this somewhat independent from any library).

The input file format is PPM

std::pair<bmp,std::vector<line>>  paint_useful( const bmp& orig, bmp& clone, std::vector<line>& retlines, bmp& layer, const std::string& outprefix, size_t x, size_t y )
{
const size_t pixels = (x*y);
const size_t lines = 0.3*pixels;
//      const size_t lines = 10000;

//      const size_t start_accurate_color = lines/4;

std::random_device rnd;

std::uniform_int_distribution<size_t> distx(0,x-1);
std::uniform_int_distribution<size_t> disty(0,y-1);
std::uniform_int_distribution<size_t> col(-15,15);
std::uniform_int_distribution<size_t> acol(0,255);

const ssize_t m = 1*1;
const ssize_t M = 50*50;

retlines.reserve( lines );

for (size_t i = retlines.size(); i < lines; ++i)
{
size_t x0;
size_t x1;

size_t y0;
size_t y1;

size_t dist = 0;
do
{
x0 = distx(rnd);
x1 = distx(rnd);

y0 = disty(rnd);
y1 = disty(rnd);

dist = distance(x0,x1,y0,y1);
}
while( dist > M || dist < m );

std::vector<std::pair<int32_t,int32_t>> points = clone.raw_line_pixels(x0,y0,x1,y1);

ssize_t r = 0;
ssize_t g = 0;
ssize_t b = 0;

for (size_t i = 0; i < points.size(); ++i)
{
r += orig.raw(points[i].first,points[i].second).r;
g += orig.raw(points[i].first,points[i].second).g;
b += orig.raw(points[i].first,points[i].second).b;
}

r += col(rnd);
g += col(rnd);
b += col(rnd);

r /= points.size();
g /= points.size();
b /= points.size();

r %= 255;
g %= 255;
b %= 255;

r = std::max(ssize_t(0),r);
g = std::max(ssize_t(0),g);
b = std::max(ssize_t(0),b);

//              r = acol(rnd);
//              g = acol(rnd);
//              b = acol(rnd);

//              if( i > start_accurate_color )
{
ssize_t dp = 0; // accumulated distance of new color to original
ssize_t dn = 0; // accumulated distance of current reproduced to original
for (size_t i = 0; i < points.size(); ++i)
{
dp += rgb_distance(
orig.raw(points[i].first,points[i].second).r,r,
orig.raw(points[i].first,points[i].second).g,g,
orig.raw(points[i].first,points[i].second).b,b
);

dn += rgb_distance(
clone.raw(points[i].first,points[i].second).r,orig.raw(points[i].first,points[i].second).r,
clone.raw(points[i].first,points[i].second).g,orig.raw(points[i].first,points[i].second).g,
clone.raw(points[i].first,points[i].second).b,orig.raw(points[i].first,points[i].second).b
);

}

if( dp > dn ) // the distance to original is bigger, use the new one
{
--i;
continue;
}
//                      if( dp > 100000 )
//                      {
//                              --i;
//                              continue;
//                      }
}

clone.raw_line(x0,y0,x1,y1,{(uint32_t)r,(uint32_t)g,(uint32_t)b});
retlines.push_back({ (int)x0,(int)y0,(int)x1,(int)y1,(int)r,(int)g,(int)b});

static time_t last = 0;
time_t now = time(0);
if( i % (lines/100) == 0 )
{
std::ostringstream fn;
fn << outprefix + "perc_" << std::setw(3) << std::setfill('0') << (i/(lines/100)) << ".bmp";
clone.write(fn.str());
bmp lc(layer);
lc.max_contrast_all();
lc.write(outprefix + "layer_" + fn.str());
}

if( (now-last) > 10 )
{
last = now;
static int st = 0;
std::ostringstream fn;
fn << outprefix + "inter_" << std::setw(8) << std::setfill('0') << i << ".bmp";
clone.write(fn.str());

++st;
}
}
clone.write(outprefix + "clone.bmp");
return { clone, retlines };
}

void erase_bad( std::vector<line>& lines, const bmp& orig )
{
ssize_t current_score = evaluate(lines,orig);

std::vector<line> newlines(lines);

uint32_t deactivated = 0;
std::cout << "current_score = " << current_score << "\n";
for (size_t i = 0; i < newlines.size(); ++i)
{
newlines[i].active = false;
ssize_t score = evaluate(newlines,orig);
if( score > current_score )
{
newlines[i].active = true;
}
else
{
current_score = score;
++deactivated;
}
if( i % 1000 == 0 )
{
std::ostringstream fn;
fn << "erase_" << std::setw(6) << std::setfill('0') << i << ".bmp";
bmp tmp(orig);
paint(newlines,tmp);
tmp.write(fn.str());
paint_layers(newlines,tmp);
tmp.max_contrast_all();
tmp.write("layers_" + fn.str());
std::cout << "\r i = " << i << std::flush;
}
}
std::cout << "\n";
std::cout << "current_score = " << current_score << "\n";
std::cout << "deactivated = " << deactivated << "\n";

bmp tmp(orig);

paint(newlines,tmp);
tmp.write("newlines.bmp");
lines.clear();
for (size_t i = 0; i < newlines.size(); ++i)
{
if( newlines[i].is_active() )
{
lines.push_back(newlines[i]);
}
}
}

• +1, very nice indeed. Do you have results for the other test images? – Nathaniel Oct 5 '14 at 9:27
• @Nathaniel: I have added some. The "simple" images are unintresting because the recreation is almost pixel perfect. – PlasmaHH Oct 6 '14 at 9:28

## Java - random lines

A very basic solution that draws random lines and compute for them the source picture average color. The background color is set to the source average color.

L = 5000, m = 10, M = 50

L = 10000, m = 10, M = 50

EDIT

I've added a genetic algorithm that handles a population of lines. At each generation, we keep only the 50% best lines, drop the others and generate randomly new ones. The criteria for keeping the lines are:

• their distance to the source picture colors is small
• the number of intersections with other lines (the smaller the better)
• their length (the longer the better)
• their angle with the nearest neighbour (the smaller the better)

To my great disappointment, the algorithm does not really seems to improve the picture quality :-( just the lines are getting more parallel.

First generation (5000 lines)

Tenth generation (5000 lines)

Playing with parameters

package line;

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.imageio.ImageIO;

import snake.Image;

public class Lines {

private final static int NB_LINES = 5000;
private final static int MIN_LENGTH = 10;
private final static int MAX_LENGTH = 50;

public static void main(String[] args) throws IOException {
BufferedImage dest = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_INT_RGB);

int [] bgColor = {0, 0, 0};
int avgRed = 0, avgGreen = 0, avgBlue = 0, count = 0;
for (int y = 0; y < src.getHeight(); y++) {
for (int x = 0; x < src.getWidth(); x++) {
int colsrc = src.getRGB(x, y);
avgRed += colsrc & 255;
avgGreen += (colsrc >> 8) & 255;
avgBlue += (colsrc >> 16) & 255;
count++;
}
}

bgColor[0] = avgBlue/count; bgColor[1] = avgGreen/count; bgColor[2] = avgRed/count;
for (int y = 0; y < src.getHeight(); y++) {
for (int x = 0; x < src.getWidth(); x++) {
dest.getRaster().setPixel(x, y, bgColor);
}
}
List<List<Point>> lines = new ArrayList<List<Point>>();
Random rand = new Random();
for (int i = 0; i < NB_LINES; i++) {
int length = rand.nextInt(MAX_LENGTH - MIN_LENGTH) + MIN_LENGTH;
double ang = rand.nextDouble() * Math.PI;
int lx = (int)(Math.cos(ang) * length); // can be negative or positive
int ly = (int)(Math.sin(ang) * length); // positive only
int sx = rand.nextInt(dest.getWidth() -1 - Math.abs(lx));
int sy = rand.nextInt(dest.getHeight() - 1- Math.abs(ly));
List<Point> line;
if (lx > 0) {
line = line(sx, sy, sx+lx, sy+ly);
} else {
line = line(sx+Math.abs(lx), sy, sx, sy+ly);
}
}

// render the picture
int [] color = {0, 0, 0};
for (List<Point> line : lines) {

avgRed = 0; avgGreen = 0; avgBlue = 0;
count = 0;
for (Point p : line) {
int colsrc = src.getRGB(p.x, p.y);
avgRed += colsrc & 255;
avgGreen += (colsrc >> 8) & 255;
avgBlue += (colsrc >> 16) & 255;
count++;
}
avgRed /= count; avgGreen /= count; avgBlue /= count;
color[0] = avgBlue; color[1] = avgGreen; color[2] = avgRed;
for (Point p : line) {
dest.getRaster().setPixel(p.x, p.y, color);
}

}
ImageIO.write(dest, "png", new File("a0.png"));

}

private static List<Point> line(int x0, int y0, int x1, int y1) {
List<Point> points = new ArrayList<Point>();
int deltax = x1 - x0;
int deltay = y1 - y0;
int tmp;
double error = 0;
double deltaerr = 0;
if (Math.abs(deltax) >= Math.abs(deltay)) {
if (x0 > x1) { // swap the 2 points
tmp = x0; x0 = x1; x1 = tmp;
tmp = y0; y0 = y1; y1 = tmp;
deltax = - deltax; deltay = -deltay;
}
deltaerr = Math.abs (((double)deltay) / deltax);
int y = y0;
for (int x = x0; x <= x1; x++) {
error += deltaerr;
if (error >= 0.5) {
if (y0 < y1) y++; else y--;
error -= 1.0;
}
}
} else {
if (y0 > y1) { // swap the 2 points
tmp = x0; x0 = x1; x1 = tmp;
tmp = y0; y0 = y1; y1 = tmp;
deltax = - deltax; deltay = -deltay;
}
deltaerr = Math.abs (((double)deltax) / deltay);   // Assume deltay != 0 (line is not horizontal),
int x = x0;
for (int y = y0; y <= y1; y++) {
error += deltaerr;
if (error >= 0.5) {
if (x0 < x1) x++; else x--;
error -= 1.0;
}
}
}
return points;
}
}

• Finally someone answered :D I'd love to see more examples. – Calvin's Hobbies Aug 20 '14 at 4:34
• @Calvin Sure. Right now I am working on improving the algorithm by keeping a population of lines, and eliminating e.g. the 20% worse, and re-generating new ones (some kind of genetic algorithm) – Arnaud Aug 20 '14 at 4:37
• I had something like that in mind, but no time to write it. Looking forward to the genetic alg. results :) – aditsu quit because SE is EVIL Aug 20 '14 at 7:35
• Perhaps you want to remove the smaller angle criterion? Why did you put it? The original image looks good although the lines don't have small intersection angle. – justhalf Aug 20 '14 at 10:22
• @justhalf Done. I've added the angle criterion in an attempt to simulate the painter brush. – Arnaud Aug 20 '14 at 10:54

# C - straight lines

A basic approach in C that operates on ppm files. The algorithm tries to place vertical lines with optimal line length to fill all pixels. The background color and the line colors are calculated as an average value of the original image (the median of each color channel):

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define SIGN(x) ((x > 0) ? 1 : (x < 0) ? -1 : 0)
#define MIN(x, y) ((x > y) ? y : x)
#define MAX(x, y) ((x > y) ? x : y)

typedef struct {
size_t width;
size_t height;

unsigned char *r;
unsigned char *g;
unsigned char *b;
} image;

typedef struct {
unsigned char r;
unsigned char g;
unsigned char b;
} color;

void init_image(image *data, size_t width, size_t height) {
data->width = width;
data->height = height;
data->r = malloc(sizeof(data->r) * data->width * data->height);
data->g = malloc(sizeof(data->g) * data->width * data->height);
data->b = malloc(sizeof(data->b) * data->width * data->height);
}

#define BUFFER_LEN 1024
int load_image(const char *filename, image* data) {
FILE *f = fopen(filename, "r");
char buffer[BUFFER_LEN];          /* read buffer */
size_t max_value;
size_t i;
fgets(buffer, BUFFER_LEN, f);
if (strncmp(buffer, "P3", 2) != 0) {
printf("File begins with %s instead of P3\n", buffer);
return 0;
}

fscanf(f, "%u", &data->width);
fscanf(f, "%u", &data->height);
fscanf(f, "%u", &max_value);
assert(max_value==255);

init_image(data, data->width, data->height);

for (i = 0; i < data->width * data->height; i++) {
fscanf(f, "%hhu", &(data->r[i]));
fscanf(f, "%hhu", &(data->g[i]));
fscanf(f, "%hhu", &(data->b[i]));
}
fclose(f);

printf("Read %zux%zu pixels from %s.\n", data->width, data->height, filename);
}

int write_image(const char *filename, image *data) {
FILE *f = fopen(filename, "w");
size_t i;
fprintf(f, "P3\n%zu %zu\n255\n", data->width, data->height);
for (i = 0; i < data->width * data->height; i++) {
fprintf(f, "%hhu %hhu %hhu ", data->r[i], data->g[i], data->b[i]);
}
fclose(f);
}

unsigned char average(unsigned char *data, size_t data_len) {
size_t i;
size_t j;
size_t hist[256];

for (i = 0; i < 256; i++) hist[i] = 0;
for (i = 0; i < data_len; i++) hist[data[i]]++;
j = 0;
for (i = 0; i < 256; i++) {
j += hist[i];
if (j >= data_len / 2) return i;
}
return 255;
}

void set_pixel(image *data, size_t x, size_t y, unsigned char r, unsigned char g, unsigned char b) {
data->r[x + data->width * y] = r;
data->g[x + data->width * y] = g;
data->b[x + data->width * y] = b;
}

color get_pixel(image *data, size_t x, size_t y) {
color ret;
ret.r = data->r[x + data->width * y];
ret.g = data->g[x + data->width * y];
ret.b = data->b[x + data->width * y];
return ret;
}

void fill(image *data, unsigned char r, unsigned char g, unsigned char b) {
size_t i;
for (i = 0; i < data->width * data->height; i++) {
data->r[i] = r;
data->g[i] = g;
data->b[i] = b;
}
}

void line(image *data, size_t x1, size_t y1, size_t x2, size_t y2, unsigned char r, unsigned char g, unsigned char b) {
size_t x, y, t, pdx, pdy, ddx, ddy, es, el;
int dx, dy, incx, incy, err;

dx=x2-x1;
dy=y2-y1;
incx=SIGN(dx);
incy=SIGN(dy);
if(dx<0) dx=-dx;
if(dy<0) dy=-dy;
if (dx>dy) {
pdx=incx;
pdy=0;
ddx=incx;
ddy=incy;
es=dy;
el=dx;
} else {
pdx=0;
pdy=incy;
ddx=incx;
ddy=incy;
es=dx;
el=dy;
}
x=x1;
y=y1;
err=el/2;
set_pixel(data, x, y, r, g, b);

for(t=0; t<el; t++) {
err -= es;
if(err<0) {
err+=el;
x+=ddx;
y+=ddy;
} else {
x+=pdx;
y+=pdy;
}
set_pixel(data, x, y, r, g, b);
}
}

color average_line(image *data, size_t x1, size_t y1, size_t x2, size_t y2) {
size_t x, y, t, pdx, pdy, ddx, ddy, es, el;
int dx, dy, incx, incy, err;
color ret;
color px;
size_t i;
size_t j;
size_t hist_r[256];
size_t hist_g[256];
size_t hist_b[256];
size_t data_len = 0;

for (i = 0; i < 256; i++) {
hist_r[i] = 0;
hist_g[i] = 0;
hist_b[i] = 0;
}

dx=x2-x1;
dy=y2-y1;
incx=SIGN(dx);
incy=SIGN(dy);
if(dx<0) dx=-dx;
if(dy<0) dy=-dy;
if (dx>dy) {
pdx=incx;
pdy=0;
ddx=incx;
ddy=incy;
es=dy;
el=dx;
} else {
pdx=0;
pdy=incy;
ddx=incx;
ddy=incy;
es=dx;
el=dy;
}
x=x1;
y=y1;
err=el/2;
px = get_pixel(data, x, y);
hist_r[px.r]++;
hist_g[px.g]++;
hist_b[px.b]++;
data_len++;

for(t=0; t<el; t++) {
err -= es;
if(err<0) {
err+=el;
x+=ddx;
y+=ddy;
} else {
x+=pdx;
y+=pdy;
}
px = get_pixel(data, x, y);
hist_r[px.r]++;
hist_g[px.g]++;
hist_b[px.b]++;
data_len++;
}

j = 0;
for (i = 0; i < 256; i++) {
j += hist_r[i];
if (j >= data_len / 2) {
ret.r = i;
break;
}
}
j = 0;
for (i = 0; i < 256; i++) {
j += hist_g[i];
if (j >= data_len / 2) {
ret.g = i;
break;
}
}
j = 0;
for (i = 0; i < 256; i++) {
j += hist_b[i];
if (j >= data_len / 2) {
ret.b = i;
break;
}
}
return ret;
}

void lines(image *source, image *dest, size_t L, float m, float M) {
size_t i, j;
float dx;
float mx, my;
float mm = MAX(MIN(source->width * source->height / L, M), m);
unsigned char av_r = average(source->r, source->width * source->height);
unsigned char av_g = average(source->g, source->width * source->height);
unsigned char av_b = average(source->b, source->width * source->height);
fill(dest, av_r, av_g, av_b);
dx = (float)source->width / L;
mx = 0;
my = mm / 2;
for (i = 0; i < L; i++) {
color avg;
mx += dx;
my += (source->height - mm) / 8;
if (my + mm / 2 > source->height) {
my = mm / 2 + ((size_t)(my + mm / 2) % (size_t)(source->height - mm));
}
avg = average_line(source, mx, my - mm / 2, mx, my + mm / 2);
line(dest, mx, my - mm / 2, mx, my + mm / 2, avg.r, avg.g, avg.b);
}
}

int main(int argc, char *argv[]) {
image source;
image dest;
size_t L;
float m;
float M;

L = atol(argv[2]);
m = atof(argv[3]);
M = atof(argv[4]);

init_image(&dest, source.width, source.height);
lines(&source, &dest, L, m, M);

write_image(argv[5], &dest);
}


## Python 3 -based off of "somewhat random lines and then some", plus sobel edge detection.

the code can theoretically run forever (so I can run it overnight for fun), but it records its progress, so all images are taken from the 1-10 min mark.

It first reads the image, and then uses sobel edge detection to find the angle of all the edges, to make sure that the lines do not trespass on another color. Once a line of the random length within (lengthmin,lengthmax) is set, it then tests to see if it contributes to the overall image. While smaller lines are better, I set the line length from 10-50.

from random import randint, uniform
import json
from PIL import Image, ImageDraw, ImageFilter
import math
k=(-1,0,1,-2,0,2,-1,0,1)
k1=(-1,-2,-1,0,0,0,1,2,1)
population=[]
lengthmin=10
lengthmax=50
number_lines=10**8
im=Image.open('0.png')
[x1,y1]=im.size
dx=0
class drawer():
def __init__(self,genome,score,filename):
self.genome=genome
self.score=score
self.filename=filename
def initpoint(self,g1):
g2=self.genome
im=Image.open('0.png')
im1=im.filter(ImageFilter.Kernel((3,3),k,1,128))
im2=im.filter(ImageFilter.Kernel((3,3),k1,1,128))
for x in range(0,number_lines):
if(x%10**4==0):
print(x*100/number_lines)
self.save()
g1.save('1.png')
(x,y)=(randint(0,x1-1),randint(0,y1-1))
w=im1.getpixel((x,y))[0]-128
z=im2.getpixel((x,y))[0]-128
w=int(w)
z=int(z)
W=(w**2+z**2)**0.5
if(W!=0):
w=(w/W)*randint(lengthmin,lengthmax)
z=(z/W)*randint(lengthmin,lengthmax)
(w,z)=(z,w)
(a,b)=(x+w,y+z)
a=int(a)
b=int(b)
x=int(x)
y=int(y)
if(a>=x1):
a=x1-1
if(b>=y1):
b=y1-1
if(a<0):
a=0
if(b<0):
b=0
if(x>=x1):
x=x1-1
if(y>=y1):
y=y1-1
if(x<0):
x=0
if(y<0):
y=0
C=[0,0,0]
D=0
E=0
F=0
G=0
W=((x-a)**2+(y-b)**2)**0.5
if(W!=0):
for Z in range(0,int(W)):
w=(Z/W)
(c,d)=((w*x+(1-w)*a),(w*y+(1-w)*b))
c=int(c)
d=int(d)
C[0]+=im.getpixel((c,d))[0]
C[1]+=im.getpixel((c,d))[1]
C[2]+=im.getpixel((c,d))[2]
C[0]/=W
C[1]/=W
C[2]/=W
C[0]=int(C[0])
C[1]=int(C[1])
C[2]=int(C[2])
for Z in range(0,int(W)):
w=(Z/W)
(c,d)=((w*x+(1-w)*a),(w*y+(1-w)*b))
c=int(c)
d=int(d)
E=0
D=0
D+=(g1.getpixel((c,d))[0]-im.getpixel((c,d))[0])**2
D+=(g1.getpixel((c,d))[1]-im.getpixel((c,d))[1])**2
D+=(g1.getpixel((c,d))[2]-im.getpixel((c,d))[2])**2
F+=D**0.5
E+=(im.getpixel((c,d))[0]-C[0])**2
E+=(im.getpixel((c,d))[1]-C[1])**2
E+=(im.getpixel((c,d))[2]-C[2])**2
G+=E**0.5
#print((G/W,F/W))
if(G<F):
for Z in range(0,int(W)):
w=(Z/W)
(c,d)=((w*x+(1-w)*a),(w*y+(1-w)*b))
c=int(c)
d=int(d)
g1.putpixel((c,d),(int(C[0]),int(C[1]),int(C[2])))
g2.append((x,y,a,b,int(C[0]%256),int(C[1]%256),int(C[2]%256)))
return(g1)
def import_file(self):
with open(self.filename, 'r') as infile: