Drawing a dashed line with pygame

Question

def draw_dashed_line(surf, color, start_pos, end_pos, width=1, dash_length=10):
 x1, y1 = start_pos
 x2, y2 = end_pos
 dl = dash_length
 if (x1 == x2):
 ycoords = [y for y in range(y1, y2, dl if y1 < y2 else -dl)]
 xcoords = [x1] * len(ycoords)
 elif (y1 == y2):
 xcoords = [x for x in range(x1, x2, dl if x1 < x2 else -dl)]
 ycoords = [y1] * len(xcoords)
 else:
 a = abs(x2 - x1)
 b = abs(y2 - y1)
 c = round(math.sqrt(a**2 + b**2))
 dx = dl * a / c
 dy = dl * b / c
 xcoords = [x for x in numpy.arange(x1, x2, dx if x1 < x2 else -dx)]
 ycoords = [y for y in numpy.arange(y1, y2, dy if y1 < y2 else -dy)]
 next_coords = list(zip(xcoords[1::2], ycoords[1::2]))
 last_coords = list(zip(xcoords[0::2], ycoords[0::2]))
 for (x1, y1), (x2, y2) in zip(next_coords, last_coords):
 start = (round(x1), round(y1))
 end = (round(x2), round(y2))
 pygame.draw.line(surf, color, start, end, width)

This function takes two coordinates and draws a colored dashed line from the first to the second coordinate. Line a = abs(x2 - x1) to line dy = dl * b / c calculates the amount x and y change for dl (dash_length). Because dx and dy are floats, I had to use numpy.arange (built-in range() doesn't allow floating-point).

Here's an example:

draw_dashed_line(screen, RED, (0, 0), (800, 600), dash_length=5)

example

Documentation for pygame.draw.line: http://www.pygame.org/docs/ref/draw.html#pygame.draw.line

Answer 1

Instead of storing all the values you're trying to draw, it might be more efficient to just get the slope of the drawn line, and compute dashes at draw time.

Considering that there's a lot of mirrored code here, consider using a point class to handle both the x and the y values at the same time!

class Point:
 # constructed using a normal tupple
 def __init__(self, point_t = (0,0)):
 self.x = float(point_t[0])
 self.y = float(point_t[1])
 # define all useful operators
 def __add__(self, other):
 return Point((self.x + other.x, self.y + other.y))
 def __sub__(self, other):
 return Point((self.x - other.x, self.y - other.y))
 def __mul__(self, scalar):
 return Point((self.x*scalar, self.y*scalar))
 def __div__(self, scalar):
 return Point((self.x/scalar, self.y/scalar))
 def __len__(self):
 return int(math.sqrt(self.x**2 + self.y**2))
 # get back values in original tuple format
 def get(self):
 return (self.x, self.y)
def draw_dashed_line(surf, color, start_pos, end_pos, width=1, dash_length=10):
 origin = Point(start_pos)
 target = Point(end_pos)
 displacement = target - origin
 length = len(displacement)
 slope = displacement/length
 for index in range(0, length/dash_length, 2):
 start = origin + (slope * index * dash_length)
 end = origin + (slope * (index + 1) * dash_length)
 pygame.draw.line(surf, color, start.get(), end.get(), width)

Answer 2

We are looking for answers that provide insightful observations about the code in the question. Answers that consist of independent solutions with no justification do not constitute a code review, and may be removed.

You could make this function way shorter, by using all of NumPy's features ...

import pygame as pg
import numpy as np
# -------------------------------- #
def draw_line_dashed(surface, color, start_pos, end_pos, width = 1, dash_length = 10, exclude_corners = True):
 # convert tuples to numpy arrays
 start_pos = np.array(start_pos)
 end_pos = np.array(end_pos)
 # get euclidian distance between start_pos and end_pos
 length = np.linalg.norm(end_pos - start_pos)
 # get amount of pieces that line will be split up in (half of it are amount of dashes)
 dash_amount = int(length / dash_length)
 # x-y-value-pairs of where dashes start (and on next, will end)
 dash_knots = np.array([np.linspace(start_pos[i], end_pos[i], dash_amount) for i in range(2)]).transpose()
 return [pg.draw.line(surface, color, tuple(dash_knots[n]), tuple(dash_knots[n+1]), width)
 for n in range(int(exclude_corners), dash_amount - int(exclude_corners), 2)]
# -------------------------------- #

• Vogel612: Welcome to Code Review! You have presented an alternative solution, but haven't reviewed the code. Please explain your reasoning (how your solution works and why it is better than the original) so that the author and other readers can learn from your thought process.