DEV Community: Siddharth Singh Tanwar

Creating art similar to 1.2 million pounds worth of painting

Siddharth Singh Tanwar — Thu, 22 Aug 2024 15:10:21 +0000

Recreating a Million-Dollar Damien Hirst Painting Using Python and Turtle Graphics

Introduction

Overview

Ever seen art and thought, "Yeah, I could make something similar to that." Well, you are not alone! If you search Damien Hirst's dot paintings online, a similar thought might cross your mind. Today we are going to test this theory using code.

Objective

We are trying to create art similar to popular artworks by artist Damien Hirst using Python code and the Turtle graphics library.

Inspiration

This blog post is inspired by Angela Yu's Python course.

Setting up the Environment

We will need Python installed on our system (the latest version is better), Turtle graphics library (which comes pre-installed when you install Python), Colorgram library (which you have to install using pip), and your favorite IDE.

Understanding the Art

Hirst's art consists of a pattern of symmetrical color dots of the same size separated by consistent space.
It seems simple enough to mimic. So let's get to it.

Coding the Painting

Creating the Canvas:

#We import the Turtle library and give it an alias as t
import turtle as t

#We create an object of the Turtle class and name it bob
bob = t.Turtle()

#We create a screen that will be our canvas which our turtle (bob)  #will draw the painting on
screen = t.Screen()

#To make the screen persistent we add the following line of code that #makes sure that the screen stays till we click on it.
screen.exitonclick()

Extracting Colors:
You can install the colorgram library from this link.

#Import the colorgram library
import colorgram

#Make a list that will store the colors extracted from a sample #Damien Hirst painting.
rgb_colors = []

#Extract the colors from the painting. You can choose how many colors #to extract, here 30 is chosen.
colors = colorgram.extract('image.jpg', 30)

#The output is a list of colorgram object of RGB values. We select #the RGB values from them.
for color in colors:
    r = color.rgb.r
    g = color.rgb.g
    b = color.rgb.b
    new_color = (r, g, b)
    rgb_colors.append(new_color)

print(rgb_colors)

#After we get the output, we can select the color list from the #terminal, store them into a variable like below, and comment the #above code.
color_list = [(245, 243, 238), (202, 164, 110), (240, 245, 241), (149, 75, 50), (222, 201, 136), (53, 93, 123), (170, 154, 41), (138, 31, 20), (134, 163, 184), (197, 92, 73), (47, 121, 86), (73, 43, 35), (145, 178, 149), (14, 98, 70), (232, 176, 165), (160, 142, 158), (54, 45, 50), (101, 75, 77), (183, 205, 171), (36, 60, 74), (19, 86, 89), (82, 148, 129), (147, 17, 19), (27, 68, 102), (12, 70, 64), (107, 127, 153), (176, 192, 208), (168, 99, 102)]

Drawing the Patterns:

#Importing random module to randomly choose colors from color list
import random

# Since we are using RGB we set the colormode to 255 as there are 0 #to 255 values of RGB.
t.colormode(255)

#For better visualization we speed up the drawing process
bob.speed("fastest")

#by default our pen draws a line, we penup to avoid that
bob.penup()

# Going to an appropriate place in the canvas to draw all the dots in #the visible area
bob.setheading(220)
bob.forward(300)

#Setting the heading in right direction to draw the dots
bob.setheading(0)
number_of_dots = 100

#drawing dots of size 20 at a distance of 50 from each other of a #random color from the color list. After every 10 dots we go the next #line
for dots in range(1, number_of_dots + 1):
    bob.dot(20, random.choice(color_list))
    bob.forward(50)

    if dots % 10 == 0:
        bob.setheading(90)
        bob.forward(50)
        bob.setheading(180)
        bob.forward(500)
        bob.setheading(0)

#hiding our drawing pen
bob.hideturtle()

Enhancements

Now there various Hirst's paintings to choose from and we can extract any number of colors from them so feel free to try out for yourself and see what kind of artwork you can come up with!

Conclusion

Overall it is a fun project and shows how easy it is to create something real from just the fundamentals of a programming language.

Understanding the -u Flag in Git: Simplify Your Workflow

Siddharth Singh Tanwar — Thu, 01 Aug 2024 14:15:08 +0000

As developers, efficiency and clarity in our workflows can make a significant difference. One Git command that helps streamline our processes is git push -u origin main. This blog post'll explore what the -u flag does and how it simplifies future Git operations.

What Does the `-u` Flag Do?

The -u flag in the git push command stands for --set-upstream. When you use git push -u origin main, it does two primary things:

Pushes the Local Branch to the Remote Repository: Just like a regular git push origin main, this command pushes your local main branch to the main branch on the remote repository named origin.
Sets the Upstream Branch: It establishes a tracking relationship between your local branch and the remote branch. This means Git now knows which remote branch your local branch is linked to, making future interactions with this branch more straightforward.

Why is Setting the Upstream Branch Important?

By setting the upstream branch, you simplify future Git commands. Without this, you would need to specify the remote branch every time you pull or push. After setting the upstream, you can use shorter commands, saving time and reducing the potential for errors.

Example Workflow

Push with Upstream Set:

git push -u origin main

Future Pushes:

git push

Pull Changes:

git pull

By using the -u flag, future git push and git pull commands will automatically reference the main branch on the origin remote, simplifying your workflow.

Checking Upstream Branch

You can see which upstream branch is set for your local branches with:

git branch -vv

This command provides a detailed view of all your local branches, their upstream branches, and their tracking status.

Conclusion

Incorporating the -u flag into your Git workflow is a small change that can have a big impact on efficiency. By setting the upstream branch, you streamline your commands and ensure a smoother, more intuitive interaction with your Git repository.

Try it out next time you push a branch for the first time, and enjoy a more efficient Git experience!

Supercharge Your Terminal: Display Git Branch in Your Bash Prompt

Siddharth Singh Tanwar — Tue, 30 Jul 2024 17:20:48 +0000

Introduction

As developers, we spend a significant amount of time in our terminal, navigating through projects and managing Git repositories. One common pitfall is forgetting which Git branch we're currently working on, leading to potential mistakes or confusion. What if your terminal could always remind you of your current Git branch? In this post, we'll walk through a simple yet powerful customization of your bash prompt that will do just that.

What We'll Achieve

Before: username@hostname:$
After: username@hostname:/project (main)$

By the end of this tutorial, your bash prompt will automatically display your current Git branch when you're in a Git repository. This small change can significantly improve your workflow, reducing the need for frequent git branch commands and helping prevent accidental commits to the wrong branch.

Prerequisites

Before we begin, ensure you have:

Bash shell (default on most Linux distributions and macOS)
Git installed
Basic familiarity with editing configuration files

Step-by-Step Guide

a. Editing the .bashrc file
Open your .bashrc file in a text editor:

nano ~/.bashrc

b. Adding the parse_git_branch function
Add this function to your .bashrc:

parse_git_branch() { git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* $.*$/(\1)/' }

c. Modifying the PS1 variable
Find your PS1 definition and modify it to include the Git branch information:

if [ "$color_prompt" = yes ]; then PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[33m\]$(parse_git_branch)\[\033[00m\]\$ ' else PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w$(parse_git_branch)\$ ' fi

d. Applying the changes
Save the file and run:

source ~/.bashrc

How It Works

The parse_git_branch function:

Runs git branch to get the list of branches
Uses sed to filter and format the output, showing only the current branch name in parentheses

The PS1 string:
\u@\h: Displays username@hostname
\w: Shows the current working directory
$(parse_git_branch): Calls our function to display the Git branch
Color codes (e.g., [\033[01;32m]) add visual distinction to different parts of the prompt

Customization Options

Change colors by modifying the color codes in PS1
Add Git status information by extending the parse_git_branch function
Include other Git information like the number of staged/unstaged files

Troubleshooting

If changes don't appear, ensure you've sourced .bashrc or opened a new terminal
Check for syntax errors in your .bashrc file
Verify that Git is installed and accessible from your PATH

Conclusion

This simple bash prompt customization can significantly enhance your development workflow. By always knowing which Git branch you're on, you can work more confidently and efficiently. I encourage you to customize your prompt further to suit your needs and workflow.

Further Resources

Bash manual: Advanced prompt customization
Git documentation: Working with branches
Bash scripting tutorials for more advanced prompt modifications

By implementing this customization, you're taking a small but significant step towards a more informative and efficient development environment.

Happy coding!

A list of lists in Python

Siddharth Singh Tanwar — Sun, 14 Jul 2024 05:30:20 +0000

Python Tip: Creating a List of Lists

When creating a list of lists in Python, it's important to understand how list multiplication works.

Using:

m = [[]] * 7

creates seven references to the same list. Modifying one list will affect all others because they reference the same object.

Instead, use list comprehension to ensure each list is independent:

m = [[] for _ in range(7)]

This way, each empty list in 'm' is a separate object, avoiding unwanted side effects.

Concurrency: Letting all cook!

Siddharth Singh Tanwar — Wed, 19 Jun 2024 11:42:02 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

Imagine a kitchen with multiple chefs cooking different dishes simultaneously. Each chef (thread) works on their tasks, but they need to share the stove (resource) without bumping into each other (race conditions). This efficient cooking dance is concurrency!

Additional Context

Concurrency is an important but difficult to understand concept when you first come across it. If we try to understand it using an analogy, it gets somewhat easier. A lot of concepts connected to it like race conditions and deadlock also become easier to understand.

DEV Community: Siddharth Singh Tanwar

Creating art similar to 1.2 million pounds worth of painting

Recreating a Million-Dollar Damien Hirst Painting Using Python and Turtle Graphics

Introduction

Overview

Objective

Inspiration

Setting up the Environment

Understanding the Art

Coding the Painting

Enhancements

Conclusion

Understanding the -u Flag in Git: Simplify Your Workflow

What Does the -u Flag Do?

Why is Setting the Upstream Branch Important?

Example Workflow

Checking Upstream Branch

Conclusion

Supercharge Your Terminal: Display Git Branch in Your Bash Prompt

Introduction

What We'll Achieve

Prerequisites

Step-by-Step Guide

How It Works

Customization Options

Troubleshooting

Conclusion

Further Resources

A list of lists in Python

Concurrency: Letting all cook!

Explainer

Additional Context

What Does the `-u` Flag Do?