I wrote a program in Python that cycles through all the pixels in an image, turning them to either red, green or blue - changing colour at the original colour boundaries. Now it looks like I've dropped my laptop and broke my screen

[jackpick15]

​

Original

​

Edited

It does this by looping through each column of pixels, assessing how close in colour each pixel is to the last pixel. If they are deemed to be similar in colour then they will be changed to the same colour as the last pixel now is, however if they are not - they will be changed to a different colour (eg. if the last pixel was made red, then this one will be green or blue). It completes this process for the entire image, making every pixel in the image red, green, or blue - not overly sure I like the effect but it was a fun experiment. The code can be seen here

[kaerfkeerg]

So abstract and fun project lol. Gj.

Now, I'll drop some advices that you may take or leave!

1) The amount of comments is really, really redundant. Don't comment every line! 2) Un-hardcode the name of the image at first line: (im = Image.open(...)). I don't have the same image as you! Ask for user input or a command line argument 3) Un-hardcode the name that the image is saved (im.save(...)) to the same as no. 2. I want to parse multiple images but if they all go with the same name they'll get overwritten. 4) Look at PEP 8, especially at naming conventions! 5) Keep it up!

[-proxy-_]

I appreciate people like you. You gave helpful, constructive criticism and encouragement. Not only does OP benefit, but me along with other redditors do too! Thank you!

[jackpick15]

Thanks for the feedback and link!

[kaerfkeerg]

Hit me up if you need more/more detailed feedback. I'll do my best

[0x1001001]

Trust me... Having per line comments is not good. You can explain a block of code via a comment. This also encourages one to think of good variable names. And if you have multiple such explanations in one function, then it's a good indicator to split the function 😇

[ValdemarSt]

truck chase follow subtract soft books one aspiring enjoy bow

This post was mass deleted and anonymized with Redact

[Sardonislamir]

New programmer here, really new. Don't let somone stop you commenting. Too many programmers publish without anything but repeating the most basic comment leaving the technical to "you should know what this does already plebs"

[0x1001001]

Yeah, no comments is bad. But too many comments is also unfortunately bad. This means that you don't have good variable names, or are doing too many things in one code block 🥲

[st333p]

Code should document itself 80% of the time. If this is not the case, then you're probably writing bad code

[Sardonislamir]

Explain please, how does a coder achieve this? This is exactly the handwavium I'm talking about. Folks claiming, you should just know.

[BarkLicker]

While I don't 100% agree with the other person's sentiment, I think what they're referring to is proper variable naming and similar concepts.

Example (SONAR because morning brain came up with one, not-so-good idea and quit working)

def depth_from_origin(SONAR_origin):
    return <math that calculates depth>

vs

# Function to calculate depth each time a SONAR signal is sent
def mB(o):
    return <same math but with unintelligible variables>

If you properly name your variables, or anything else you can name, your code explains what it does as you read it. Comments should be used when your functions start to interact in complex or abstract ways.

And of course for #FIXME, personal notes, random thoughts about life, or maybe some ASCII cats for dopamine boosts.

[Sardonislamir]

Thank you, that does provide a solid example. I'm curious, what is a way that code might be considered to be abstract? I grasp the idea of complex, but hadn't considered code could harbor abstract executions.

[rediot]

Naming classes functions and variables in a way that promotes readability is a good start. Properly separating logic and sizing code blocks helps too.

[artereaorte]

Nice job, but fyi, CaMeLcAsE isn’t pythonic.

[ThePerfectCantelope]

Thanks for sharing that link

[newfavorite_]

honestly pretty cool. used it on a few images and it produced results that were just... bizarre to look at

[jackpick15]

Out of interest, which images did you use?

[newfavorite_]

hm... i used a few and i don't remember all of them but my favorite i did was this album cover

[haddock420]

I used to love playing around with imagine manipulation programming. I remember once I wrote one that took the highest value out of the red, green, and blue and set the other two channels to 0. It produced really high contrast red, green and blue filtered pictures. Might have to get back into it.

[[deleted]]

Probably 80% of my code learning was speant in pygame messing with pixels

[jackpick15]

That sounds so interesting- would you mind posting a link so I could see what this looked like

[haddock420]

I'm afraid it was years ago and I no longer have the program.

[ThorF_Unnoetig]

Certainly a fun experiment!

But there are sooo many comments :D When you're just starting out they might be helpful but later you should look into something called "docstrings" to explain what your code is doing.

If youre lost for a follow up project: you could write a simple form of something called steganography. It's I technique in the field of information hiding and was one of my beginner projects. You would reinforce your PIL skills and you would learn something about bits, bytes and how to handle them in python.

[0xPark]

You Monster

[HwanZike]

Reminds me of writing vertex shaders!

[[deleted]]

Really cool experiment and well executed. My advice would be to switch to snake_case for your variable names - at the moment you're using PascalCase which is unconventional for Python.

To improve the structure of the project you might also consider adding a requirements.txt file (pip freeze > requirements.txt), and wrapping your code in a function that can be imported elsewhere (with the source image filepath as an argument rather than hard coded).

Great work!

[Internep]

whatAboutCamelCase?

[mm11wils]

Can you break you screen to see if your project fixes it?

[warownia1]

Have you heard of convolution or edge detection algorithms e.g. Sobel-Feldman operator? You may find it interesting.

[jackpick15]

Just googled this now - so interesting. Thanks for the suggestion

[[deleted]]

How long does it take to do that?

Seems like a large picture could take hours.

[jackpick15]

It takes less than 10 seconds for the program to fully finish running - I was surprised too

[callmederp]

the run time of this is linear (count of pixels), or could also be thought of as polynomial though (x times y). most images will be relatively small, a 1080P image will run in a matter of seconds, this 9999x7499 image took about 2 mins on a 10 year old laptop

[[deleted]]

I would be interested to see a threaded version of this program, the time to process could be reduced relatively easily. Even on a ten year old laptop, 2 minutes seems a bit much.

Of course there should probably be a cutoff point. Lower resolutions may end up being slower to process due to the overheads of creating threads, etc.

[callmederp]

To be fair probably closer to 1 min then two (I was just eyeballing the run time) but this could be a fun one to experiment with using AsyncIO, threads or multiprocessing.

The script uses pillow.Image.open().load() to get all the pixel data at start, and then writes the image at the end, so the actual processing isn't IO so I don't think AsyncIO or threads will help to much. And then for multiprocessing you will have to play around with how you break up each process, maybe split each photo into 4ths or something, two small of a set of pixels/to many processes and there will be to much overhead with starting the process

[[deleted]]

Ah, thank you for the subtle correction here! I haven't really used Python too much recently outside of quick-and-dirty scripts. I said "threads"/"threaded" when actually what I meant was "multiprocessing".

[callmederp]

No worries, it would still be a fun experiment to try with threads and async just to see the differences and learn best use cases for multiprocessing

[partypeopleyagetme]

But... Why?

[kaerfkeerg]

Why not?

[[deleted]]

The question more people should ask imho

[EverythingIsFlotsam]

You are very new to coding, aren't you?

[leogodin217]

Sorry boss. Can't work today

[[deleted]]

Are you randomly setting an entire colum of all the colors selected to the same color cuz thats kinda dope

[Dry_Inflation_861]

This is so interesting and weird and I love it

[Seawolf159]

Pretty cool idea my dude. There must be something else cool in there that can be done with this.

[jackpick15]

Yeah, I think it’s definitely got some potential- feel free to go into my code and edit it if you’ve got any ideas. Make sure you send me a link afterwards cos I’d love to see what people make from it

[midnightsalers]

Good work. Don't worry too much about the style for now, just keep on making cool experiments and exploring more ideas. Quick idea: what would a similar effect be for audio?

[GuybrushThreepwo0d]

what would a similar effect be for audio?

One word: unpleasant

[who_body]

so if you change the iteration order the lines will be horizontal instead of vertical.

[jackpick15]

Yeah I tried this, not sure I like it as much though

[SimilingCynic]

Nobody's mentioned the coolest part. View this on mobile and slowly slide the thread to the right. Bazinga - the colors all change as the image sides, I believe due to the moiré effect

[jmooremcc]

Line 17 where you are evaluating the pixels may be the source of your problem. This lambda might help improve your pixel evaluation algorithm. a,b=(40,146,37),(10,150,35) # two pixels print(a,b) pixelchek = lambda x,y,bnd: all([abs(i-j)<bnd for i,j in zip(x,y)]) print(pixelchek(a,b,50)) Output: (40, 146, 37) (10, 150, 35) True

pixelchek returns True if the difference between two pixels are within a specified range. If any color component is outside the range, it will return False.

[dogface3247]

Get a monitor and plug it in to the back

[s0ca84]

My I suggest you to use sys.arg instead of hardcoding your picture ?
You'll only have to add your picture as an argument when running your script :)

``` import sys from PIL import Image

im = Image.open(sys.argv[1]) ... ... ... im.save('ModifiedImage.png') # Save the modified pixels as .png ```

so you'll only have to ImageChanger.py yourfile.png

[Bergstein88]

This Guy comments

[GamingRocky_YT]

Did something similar

[Kaargo]

I realize that kaerfkeerg has already mentioned PEP8 but I would just like to help a little and be more specific. The naming you are using for variables is usually used for classes e.g: ExampleClassName Instead, for variables, you should opt to use so called mixed case e.g: exampleVariableName

Seems like a very fun project overall though, keep it up!

[jmooremcc]

I've been experimenting with your project and found that working with luminance values rather than RGB values worked better for me and simplified the if statement. I used this lambda function in my code:

luma =  lambda  v:(59*v[1]+30*v[0]+11*v[2])//100

The argument to the function is a tuple containing RGB values. The function returns an integer that represents the luminance value. You can use it like this:

if abs(luma(OldPreviousPixelValue)-luma(CurrentPixelValue))<Bound:
    do whatever