LineDream 0.3.15__py3-none-any.whl

LineDream/__init__.py

@@ -0,0 +1,37 @@
+from .primitives.Line import Line
+from .primitives.BaseShape import BaseShape
+from .primitives.Ellipse import Circle, Ellipse, Point, Arc
+from .primitives.Rectangle import Rectangle, Square
+from .primitives.Group import Group
+from .primitives.Text import Text
+from .environment.Canvas import _Canvas
+from .helpers.CircleMath import CircleMath
+# from .primitives.TextLine import TextLine
+# from .environment.Tweaks import Tweaks
+
+Canvas = _Canvas
+"""
+Canvas Singleton Object. This controls the output 'canvas', and rendering of the draw loop.
+
+### Attributes
+- width
+- height
+"""
+# Note, I had to do this Canvas=_Canvas thing so these ^ doc strings would work.
+
+__all__ = [
+	'Line',
+	'Circle',
+	'Ellipse',
+	'Arc',
+	'Point',
+	'Rectangle',
+	'Square',
+	'Group',
+	'CircleMath',
+	'BaseShape',
+	'Canvas',
+	'Text'
+]
+
+

LineDream/__main__.py

@@ -0,0 +1,7 @@
+from .primitives.Line import Line
+from .primitives.Ellipse import Circle, Ellipse, Point
+from .primitives.Rectangle import Rectangle, Square
+from .environment.Canvas import _Canvas
+
+def main():
+	print('entry point')

LineDream/__version__.py

@@ -0,0 +1,26 @@
+# Part of LineDream: A Python package for creative coding
+# Copyright (C) 2020- Marc Leonard
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+__title__ = 'LineDream'
+__description__ = 'A creative coding library...'
+__url__ = 'https://linedream.marcrleonard.com/'
+# __url__ = 'https://github.com/marcrleonard/LineDream'
+__version__ = '0.3.14'
+__author__ = 'Marc Leonard'
+__author_email__ = 'marc.r.leonard@gmail.com'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (C) 2023 - Marc Leonard'

LineDream/environment/Canvas.py

@@ -0,0 +1,145 @@
+import drawsvg
+from PIL import Image
+import io
+
+
+'''
+SHAPES TO ADD:
+	- Rectangle/Square?
+	- Mesh?
+	- Curves (via paths)
+
+
+'''
+
+class BaseCanvas(object):
+	'''The canvas object controls all the render controls.'''
+	def __init__(self, x=1200, y=800, units=None):
+		self.width = x
+		self.height = y
+
+		self.units=units
+
+		self.background_color= None
+
+		self.draw_queue = []
+
+		self._frame_index = 0
+
+	@property
+	def frame_index(self):
+		return self._frame_index
+
+
+	def save(self, filename, open_viewer=False, flush=True, as_string=False):
+
+		bg = {}
+		if self.background_color:
+			bg = {
+				"style": f'background-color:{self.background_color}'
+			}
+
+		svg_canvas = drawsvg.Drawing(
+			self.width,
+			self.height,
+			origin=(0, 0),
+			**bg,
+			xmlns__inkscape = "http://www.inkscape.org/namespaces/inkscape"
+		)
+
+		# There may be a better way to do this through the init above, but I found it confusing.
+		# it was much easier to just hardcode it.
+		svg_canvas.viewBox = (0, 0, self.width, self.height)
+
+		if self.units:
+			svg_canvas.width = f'{self.width}{self.units}'
+			svg_canvas.height = f'{self.height}{self.units}'
+
+		for shape in self.draw_queue:
+
+			if shape.is_text:
+
+				for line in shape.text_lines:
+
+					if len(line) <= 1:
+						continue
+
+					if len(line) == 2:
+						svg_obj = drawsvg.Line(line[0].real, line[0].imag, line[1].real, line[1].imag, fill=shape.fill_color, stroke=shape.stroke_color,
+											   stroke_width=shape.stroke_width, fill_opacity=shape.fill_opacity)
+					else:
+
+						start_x = line[0].real
+						start_y = line[0].imag
+
+						addl_points = []
+						for c in line[1:]:
+							addl_points.append(c.real)
+							addl_points.append(c.imag)
+						#*(c.real, c.imag) for c in line[1:]
+
+						svg_obj = drawsvg.Lines(start_x, start_y, *addl_points,
+						fill=shape.fill_color, stroke=shape.stroke_color,
+						stroke_width=shape.stroke_width, fill_opacity=shape.fill_opacity
+						)
+					# else:
+					# 	path = drawsvg.Lines((c.real, c.imag) for c in line)
+
+					svg_canvas.append(svg_obj)
+
+
+			elif shape.is_group:
+				g = drawsvg.Group(
+					id=shape.id,
+					inkscape__label=shape.label,
+					inkscape__groupmode="layer"
+				)
+				for shape in shape.items:
+					svg_obj = shape.svg_object
+					if svg_obj:
+						g.append(svg_obj)
+				svg_canvas.append(g)
+
+			else:
+				svg_obj = shape.svg_object
+				if svg_obj:
+					svg_canvas.append(svg_obj)
+
+
+		if open_viewer:
+			c = svg_canvas.rasterize()
+			image_stream = io.BytesIO(c.png_data)
+			# Open the image using PIL from the BytesIO object
+			im = Image.open(image_stream)
+
+			# Display the image
+			im.show()
+
+			return True
+
+		if as_string:
+			return svg_canvas.as_svg(header='')
+
+		else:
+
+			svg_canvas.save_svg(filename)
+
+		if flush:
+			self.flush()
+
+	def flush(self):
+		'''Clear the render queue'''
+		self.draw_queue=[]
+
+	def remove_by_id(self, id):
+		'''This function is used to remove an item from teh draw queue by its id. It is not particularly fast
+		since it loops through the render queue. The reason why I added this is to remove an object after it's been
+		added to a group. I haven't fully thought through a better way to implement groups, so this will have to do for now.
+		Another idea would be to add a dict of id:obj for each, then when we delete the key, it somehow deletes the object too.
+		I dunno. I'll think about it more.'''
+		for idx, item in enumerate(self.draw_queue):
+			if item.id == id:
+				del self.draw_queue[idx]
+				return True
+
+_Canvas = BaseCanvas()

LineDream/environment/Tweaks.py

@@ -0,0 +1,9 @@
+class TweaksBase:
+	def __init__(self):
+		pass
+
+	def add_tweak(self, t):
+
+		return t
+
+Tweaks = TweaksBase()

LineDream/helpers/CircleMath.py

@@ -0,0 +1,30 @@
+import math
+import numpy as np
+
+class CircleMath:
+	'''
+	A class with helper methods for circles
+	'''
+
+	@staticmethod
+	def distance_to_coords(degrees, distance):
+		angle_radians = degrees * math.pi / 180
+		x = math.cos(angle_radians) * distance
+		y = math.sin(angle_radians) * distance
+		return x, y
+
+	@staticmethod
+	def rotate(p, origin=(0, 0), degrees=0):
+		# https://stackoverflow.com/a/58781388/6775715
+		angle = np.deg2rad(degrees)
+		R = np.array([[np.cos(angle), -np.sin(angle)],
+					  [np.sin(angle), np.cos(angle)]])
+		o = np.atleast_2d(origin)
+		p = np.atleast_2d(p)
+		rv = np.squeeze((R @ (p.T - o.T) + o.T).T)
+		#todo: remove this once native numpy arrays are supported
+		return rv.tolist()
+
+	@staticmethod
+	def degrees_to_radians(degrees):
+		return (math.radians(degrees / math.pi))

LineDream/primitives/BaseShape.py

@@ -0,0 +1,332 @@
+# this should mirror what is available in an svg
+import math
+import sys
+import uuid
+
+import numpy as np
+import drawsvg
+
+from ..environment.Canvas import _Canvas
+from ..helpers.CircleMath import CircleMath
+
+class BaseShape(object):
+	'''All provided primitives inherit from this class. If a user wants to make their own primitive, its recommended to
+	inherit from this class so the new primative is added to the draw queue.'''
+	def __init__(self,**kwargs):
+		self._vertices = np.array([])
+		self._fill_color='none'
+		self._stroke_color='black'
+		self._stroke_width=1
+		self._close_path = False
+		self._fill_opacity = 1.0
+
+		self.is_circle=False
+		self.is_arc=False
+		self.is_group = False
+		self.is_text = False
+
+		self.id = str(uuid.uuid4())
+
+		for k,v in kwargs.items():
+			if hasattr(self, k):
+				setattr(self, k, v)
+			else:
+				raise AttributeError(f'Invalid parameter "{k}" for {self.__class__.__name__}. Attribute does not exist.')
+
+		_Canvas.draw_queue.append(self)
+
+	@property
+	def fill_color(self):
+		'''The fill color of the shape'''
+		return self._fill_color
+
+	@fill_color.setter
+	def fill_color(self, v):
+		self._fill_color = v
+
+
+	@property
+	def fill_opacity(self):
+		'''The fill opacity of the shape'''
+		return self._fill_opacity
+
+	@fill_opacity.setter
+	def fill_opacity(self, v):
+		self._fill_opacity = v
+
+	@property
+	def close_path(self):
+		'''Upon rendering the shape, the last vertex will connect to the first vertex'''
+		return self._close_path
+
+	@close_path.setter
+	def close_path(self, v:bool):
+		self._close_path = v
+
+	@property
+	def stroke_color(self):
+		'''The stroke color of the shape'''
+		return self._stroke_color
+
+	@stroke_color.setter
+	def stroke_color(self, v):
+		self._stroke_color = v
+
+	@property
+	def stroke_width(self):
+		'''The stroke width of the shape'''
+		return self._stroke_width
+
+	@stroke_width.setter
+	def stroke_width(self, v):
+		self._stroke_width = v
+
+	@property
+	def vertices(self):
+		'''The list of vertices'''
+		return self._vertices
+
+	@property
+	def first_vertex(self):
+		'''The first vertex of the shape'''
+		rv = (None, None)
+		if  self.vertices.size > 0:
+			_rv = self.vertices[0]
+			rv = (_rv[0], _rv[1])
+
+		return rv
+
+	@property
+	def min_x(self):
+		'''The smallest x value of all the vertices'''
+		rv = self.first_vertex[0]
+
+		_v = self.vertices.tolist()
+
+		for vertex in _v:
+			x = vertex[0]
+			if x < rv:
+				rv = x
+		return rv
+
+	@property
+	def max_x(self):
+		'''The largest x value of all the vertices'''
+		rv = self.first_vertex[0]
+
+		_v = self.vertices.tolist()
+
+		for vertex in _v:
+			x = vertex[0]
+			if x > rv:
+				rv = x
+		return rv
+
+	@property
+	def min_y(self):
+		'''The smallest y value of all the vertices'''
+		rv = self.first_vertex[1]
+
+		_v = self.vertices.tolist()
+
+		for vertex in _v:
+			y = vertex[1]
+			if y < rv:
+				rv = y
+		return rv
+
+	@property
+	def max_y(self):
+		'''The largest y value of all the vertices'''
+		rv = self.first_vertex[1]
+
+		_v = self.vertices.tolist()
+
+		for vertex in _v:
+			y = vertex[1]
+			if y > rv:
+				rv = y
+		return rv
+
+	@property
+	def center(self):
+		'''The center of the shape based on the min/max x/y'''
+		x = ((self.max_x - self.min_x)/2) + self.min_x
+		y = ((self.max_y - self.min_y)/2) + self.min_y
+		return (x,y)
+
+	def add_vertex(self, x, y, z=0):
+		'''Append a set of vertexes to the primitive shape'''
+
+		l = self._vertices.tolist()
+		l.append([x,y,z,1])
+
+		self._vertices = np.array(l)
+
+		return self
+
+
+	def transform(self, x, y, z=0):
+		'''Transform the vertices based on x/y coords'''
+
+		translate_matrix = np.identity(4)
+		translate_matrix[0, -1] = x
+		translate_matrix[1, -1] = y
+		translate_matrix[2, -1] = z
+
+
+		self._vertices = np.dot(self._vertices, translate_matrix.T)[:, :4]
+		return self
+
+
+	def rotate(self, theta, origin=None, axis=np.array([0, 0, 1])):
+		"""Rotate the shape by the given angle along the given axis.
+
+		:param theta: The angle by which to rotate (in degrees)
+		:type theta: float
+
+		:param axis: The axis along which to rotate (defaults to the z-axis)
+		:type axis: np.ndarray or list
+
+	   """
+
+		# Convert degrees to radians
+		theta = theta * math.pi / 180
+
+		axis = np.array(axis[:])
+
+		x = axis[0]
+		y = axis[1]
+		z = axis[2]
+
+		s = np.sin(theta)
+		c = np.cos(theta)
+		c1 = 1 - c
+
+		rotation = np.identity(4)
+
+		rotation[0, 0] = x * x * c1 + c
+		rotation[0, 1] = x * y * c1 - z * s
+		rotation[0, 2] = x * z * c1 + y * s
+		rotation[1, 0] = y * x * c1 + z * s
+		rotation[1, 1] = y * y * c1 + c
+		rotation[1, 2] = y * z * c1 - x * s
+		rotation[2, 0] = x * z * c1 - y * s
+		rotation[2, 1] = y * z * c1 + x * s
+		rotation[2, 2] = z * z * c1 + c
+
+		if origin == None:
+			x_c,y_c = self.center
+		else:
+			x_c = origin[0]
+			y_c = origin[1]
+
+		self.transform(-x_c, -y_c)
+
+
+		rotation[0, -1] = x_c
+		rotation[1, -1] = y_c
+		rotation[2, -1] = 1
+
+		self._vertices = np.dot(self._vertices, rotation.T)[:, :4]
+
+		return self
+
+
+	def rotate_x(self, theta):
+		"""This is a convenience function to rotate the shape along the x axis.
+
+		:param theta: The angle by which to rotate (in degrees)
+		:type theta: float
+
+		:returns: The rotation matrix used to apply the transformation.
+		:rtype: np.ndarray
+
+		"""
+		self.rotate(theta, axis=np.array([1, 0, 0]))
+		return self
+
+	def rotate_y(self, theta):
+		"""This is a convenience function to rotate the shape along the y axis.
+
+		:param theta: The angle by which to rotate (in degrees)
+		:type theta: float
+
+		:returns: The rotation matrix used to apply the transformation.
+		:rtype: np.ndarray
+
+	   """
+		self.rotate(theta, axis=np.array([0, 1, 0]))
+		return self
+
+	def rotate_z(self, theta):
+		"""This is a convenience function to rotate the shape along the z axis.
+
+		:param theta:The angle by which to rotate (in degrees)
+		:type theta: float
+
+		:returns: The rotation matrix used to apply the transformation.
+		:rtype: np.ndarray
+
+	   """
+		self.rotate(theta, axis=np.array([0, 0, 1]))
+		return self
+
+
+	def scale(self, amt, amt_y=None, origin=None):
+		"""Scale the shape by the given amount.
+
+		:param amt: Scale factor for x-axis (2.0 = twice as big)
+		:type amt: float
+		:param amt_y: Scale factor for y-axis (defaults to amt for uniform scaling)
+		:type amt_y: float
+		:param origin: Origin point for scaling (defaults to shape center)
+		:type origin: tuple
+		"""
+
+		if amt_y == None:
+			amt_y = amt
+
+		scale_matrix = np.identity(4)
+		scale_matrix[0, 0] = amt
+		scale_matrix[1, 1] = amt_y
+		scale_matrix[2, 2] = 1  # default for z
+
+		self._vertices = self._vertices.dot(scale_matrix)
+
+		return self
+
+
+	@property
+	def svg_object(self):
+
+		if len(self.vertices) > 0:
+
+			verts = self.vertices
+
+			verts = verts.tolist()
+
+			# # verts = vertices.tolist()
+			if len(verts)== 0 :
+				print(f'verts contains one item of {[[0.0, 0.0, 0.0]]} ... continuing.')
+				return None
+
+			start_l = verts.pop(0)
+			start_x = start_l[0]
+			start_y = start_l[1]
+
+			other_verts = []
+			for o_v in verts:
+				x = o_v[0]
+
+				y = o_v[1]
+
+				# z = o_v[2]
+				other_verts.append(x)
+				other_verts.append(y)
+
+			return drawsvg.Lines(start_x, start_y, *other_verts, fill=self.fill_color, stroke=self.stroke_color,
+								stroke_width=self.stroke_width, fill_opacity=self.fill_opacity, close=self.close_path)
+
+		else:
+			raise Exception("This does not have vertices or a custom svg_object, so it cannot be rendered.")