#!/usr/bin/env python
# -*- coding: utf-8 -*-

import inkex
import simplestyle
import math
import string
import simpletransform


# Function for calculating a point from the origin when you know the distance
# and the angle
def calculatePoint(angle, distance):
	if (angle < 0 or angle > 360):
		return None
	else:
		return [
			distance * math.cos(math.radians(angle)),
			distance * math.sin(math.radians(angle))]


class EncoderDiskGenerator(inkex.Effect):

	def __init__(self):
		inkex.Effect.__init__(self)
		self.OptionParser.add_option("--tab",
					action="store", type="string",
					dest="tab", default="rotary_enc",
					help="Selected tab")
		self.OptionParser.add_option("--diameter",
					action="store", type="float",
					dest="diameter", default=0.0,
					help="Diameter of the encoder disk")
		self.OptionParser.add_option("--hole_diameter",
					action="store", type="float",
					dest="hole_diameter", default=0.0,
					help="Diameter of the center hole")
		self.OptionParser.add_option("--segments",
					action="store", type="int",
					dest="segments", default=0,
					help="Number of segments")
		self.OptionParser.add_option("--outer_encoder_diameter",
					action="store", type="float",
					dest="outer_encoder_diameter", default=0.0,
					help="Diameter of the outer encoder disk")
		self.OptionParser.add_option("--outer_encoder_width",
					action="store", type="float",
					dest="outer_encoder_width", default=0.0,
					help="Width of the outer encoder disk")
		self.OptionParser.add_option("--inner_encoder_diameter",
					action="store", type="float",
					dest="inner_encoder_diameter", default=0.0,
					help="Diameter of the inner encoder disk")
		self.OptionParser.add_option("--inner_encoder_width",
					action="store", type="float",
					dest="inner_encoder_width", default=0.0,
					help="Width of the inner encoder disk")
		self.OptionParser.add_option("--bits",
					action="store", type="int",
					dest="bits", default=1,
					help="Number of bits/tracks")
		self.OptionParser.add_option("--encoder_diameter",
					action="store", type="float",
					dest="encoder_diameter", default=0.0,
					help="Outer diameter of the last track")
		self.OptionParser.add_option("--track_width",
					action="store", type="float",
					dest="track_width", default=0.0,
					help="Width of one track")
		self.OptionParser.add_option("--track_distance",
					action="store", type="float",
					dest="track_distance", default=0.0,
					help="Distance between tracks")
		self.OptionParser.add_option("--bm_diameter",
					action="store", type="float",
					dest="bm_diameter", default=0.0,
					help="Diameter of the encoder disk")
		self.OptionParser.add_option("--bm_hole_diameter",
					action="store", type="float",
					dest="bm_hole_diameter", default=0.0,
					help="Diameter of the center hole")
		self.OptionParser.add_option("--bm_bits",
					action="store", type="string",
					dest="bm_bits", default="",
					help="Bits of segments")
		self.OptionParser.add_option("--bm_outer_encoder_diameter",
					action="store", type="float",
					dest="bm_outer_encoder_diameter", default=0.0,
					help="Diameter of the outer encoder disk")
		self.OptionParser.add_option("--bm_outer_encoder_width",
					action="store", type="float",
					dest="bm_outer_encoder_width", default=0.0,
					help="Width of the outer encoder disk")
		self.OptionParser.add_option("--brgc_diameter",
					action="store", type="float",
					dest="brgc_diameter", default=0.0,
					help="Diameter of the encoder disk")
		self.OptionParser.add_option("--stgc_diameter",
					action="store", type="float",
					dest="stgc_diameter", default=0.0,
					help="Diameter of the encoder disk")
		self.OptionParser.add_option("--brgc_hole_diameter",
					action="store", type="float",
					dest="brgc_hole_diameter", default=0.0,
					help="Diameter of the center hole")
		self.OptionParser.add_option("--cutouts",
					action="store", type="int",
					dest="cutouts", default=1,
					help="Number of cutouts")
		self.OptionParser.add_option("--sensors",
					action="store", type="int",
					dest="sensors", default=1,
					help="Number of sensors")
		self.OptionParser.add_option("--stgc_hole_diameter",
					action="store", type="float",
					dest="stgc_hole_diameter", default=0.0,
					help="Diameter of the center hole")
		self.OptionParser.add_option("--stgc_encoder_diameter",
					action="store", type="float",
					dest="stgc_encoder_diameter", default=0.0,
					help="Outer diameter of the last track")
		self.OptionParser.add_option("--stgc_track_width",
					action="store", type="float",
					dest="stgc_track_width", default=0.0,
					help="Width of track")

	# This function just concatenates the point and the command and returns
	# the data string
	def parsePathData(self, command, point):

		path_data = command + ' %f ' % point[0] + ' %f ' % point[1]
		return path_data

	# Creates a gray code of size bits (n >= 1) in the format of a list
	def createGrayCode(self, bits):

		gray_code = [[False], [True]]

		if bits == 1:
			return gray_code

		for i in range(bits - 1):
			temp = []
			# Reflect values
			for j in range(len(gray_code[0]), 0, -1):
				for k in range(0, len(gray_code)):
					if j == len(gray_code[0]):
						temp.append([gray_code[k][-j]])
					else:
						temp[k].append(gray_code[k][-j])
			while temp:
				gray_code.append(temp.pop())
			# Add False to the "old" values and true to the new ones
			for j in range(0, len(gray_code)):
				if j < len(gray_code) / 2:
					gray_code[j].insert(0, False)
				else:
					gray_code[j].insert(0, True)
			temp = []

		return gray_code

	# This function returns the segments for a gray encoder
	def drawGrayEncoder(self, line_style, bits, encoder_diameter, track_width,
		track_distance):
		gray_code = self.createGrayCode(bits)

		segments = []
		segment_size = 0
		start_angle_position = 0
		index = 0
		current_encoder_diameter = encoder_diameter
		previous_item = False
		position_size = 360.0 / (2 ** bits)

		for i in range(len(gray_code[0]) - 1, -1, -1):
			for j in gray_code:
				if j[i]:
					segment_size += 1
					if segment_size == 1:
						start_angle_position = index
					previous_item = True
				elif not j[i] and previous_item:
					segments.append(
						self.drawSegment(line_style,
						start_angle_position * position_size,
						segment_size * position_size,
						current_encoder_diameter,
						track_width))

					segment_size = 0
					previous_item = False
					start_angle_position = 0

				index += 1

			if previous_item:
				segments.append(self.drawSegment(line_style,
					start_angle_position * position_size,
					segment_size * position_size,
					current_encoder_diameter, track_width))
				segment_size = 0
				previous_item = False
				start_angle_position = 0
			current_encoder_diameter -= (2 * track_distance + 2 * track_width)
			index = 0

		return segments

	# Check if there is too many cutouts compared to number of sensors
	def validSTGrayEncoder(self, cutouts, sensors):
		if sensors < 6 and cutouts > 1:
			pass
		elif sensors <= 10 and cutouts > 2:
			pass
		elif sensors <= 16 and cutouts > 3:
			pass
		elif sensors <= 23 and cutouts > 4:
			pass
		elif sensors <= 36 and cutouts > 5:
			pass
		else:
			return True

		return False

	# This function returns the segments for a single-track gray encoder
	def drawSTGrayEncoder(
		self, line_style, cutouts, sensors, encoder_diameter, track_width):

		segments = []
		resolution = 360.0 / (cutouts * 2 * sensors)
		current_angle = 0.0
		added_angle = ((2 * cutouts + 1) * resolution)
		for n in range(cutouts):
			current_segment_size = ((n * 2 + 2) * cutouts + 1) * resolution
			segments.append(
				self.drawSegment(
					line_style, current_angle,
					current_segment_size,
					encoder_diameter, track_width))
			current_angle += added_angle + current_segment_size

		return segments

	def drawLabel(self, group, angle, segment_angle, outer_diameter, labelNum):
		outer_radius = outer_diameter / 2
		label_angle = angle + (segment_angle / 2)
		point = calculatePoint(label_angle, outer_radius)
		matrix = simpletransform.parseTransform(
			'rotate(' + str(label_angle + 90) + ')')
		matrix_str = str(matrix[0][0]) + "," + str(matrix[0][1])
		matrix_str += "," + str(matrix[1][0]) + "," + str(matrix[1][1]) + ",0,0"
		text = {
			'id': 'text' + str(labelNum),
			#'sodipodi:linespacing': '0%',
			'style': 'font-size: 6px;font-style: normal;font-family: Sans',
			#'transform': 'matrix(' + matrix_str + ')',
			'x': str(point[0]),
			'y': str(point[1]),
			#'xml:space': 'preserve'
			}
		textElement = inkex.etree.SubElement(group, inkex.addNS('text', 'svg'), text)
		#tspanElement = inkex.etree.Element(
		#	textElement, '{%s}%s' % (svg_uri, 'tspan'), tspan)
		textElement.text = string.printable[labelNum % len(string.printable)]

		self.current_layer.append(textElement)

	# This function creates the path for one single segment
	def drawSegment(self, line_style, angle, segment_angle, outer_diameter, width):

		path = {'style': simplestyle.formatStyle(line_style)}
		path['d'] = ''
		outer_radius = outer_diameter / 2

		# Go to the first point in the segment
		path['d'] += self.parsePathData(
			'M', calculatePoint(angle, outer_radius - width))

		# Go to the second point in the segment
		path['d'] += self.parsePathData('L', calculatePoint(angle, outer_radius))

		# Go to the third point in the segment, draw an arc
		point = calculatePoint(angle + segment_angle, outer_radius)
		path['d'] += self.parsePathData('A', [outer_radius, outer_radius]) + \
					'0 0 1' + self.parsePathData(' ', point)

		# Go to the fourth point in the segment
		point = calculatePoint(angle + segment_angle, outer_radius - width)
		path['d'] += self.parsePathData('L', point)

		# Go to the beginning in the segment, draw an arc
		point = calculatePoint(angle, outer_radius - width)
		# 'Z' closes the path
		path['d'] += (self.parsePathData(
			'A',
			[outer_radius - width, outer_radius - width]) +
				'0 0 0' + self.parsePathData(' ', point) + ' Z')

		# Return the path
		return path

	# This function adds an element to the document
	def addElement(self, element_type, group, element_attributes):
		inkex.etree.SubElement(
			group, inkex.addNS(element_type, 'svg'),
			element_attributes)

	def drawCircles(self, hole_diameter, diameter):
		# Attributes for the center hole, then create it, if diameter is 0, dont
		# create it
		circle_elements = []
		attributes = {
			'style': simplestyle.formatStyle({'stroke': 'none', 'fill': 'black'}),
			'r': str(hole_diameter / 2)
		}
		if self.options.hole_diameter > 0:
			circle_elements.append(attributes)

		# Attributes for the guide hole in the center hole, then create it
		attributes = {
			'style': simplestyle.formatStyle(
				{'stroke': 'white', 'fill': 'white', 'stroke-width': '0.1'}),
			'r': '1'
		}
		circle_elements.append(attributes)

		# Attributes for the outer rim, then create it
		attributes = {
			'style': simplestyle.formatStyle(
				{'stroke': 'black', 'stroke-width': '1', 'fill': 'none'}),
			'r': str(diameter / 2)
		}
		if self.options.diameter > 0:
			circle_elements.append(attributes)

		return circle_elements

	def drawCommonCircles(self, group, diameter, hole_diameter):
		circle_elements = self.drawCircles(hole_diameter, diameter)

		for circle in circle_elements:
			self.addElement('circle', group, circle)

	def effectBrgc(self, group, line_style, diameter, hole_diameter):

		if (((self.options.encoder_diameter / 2) -
			(self.options.bits * self.options.track_width +
			(self.options.bits - 1) * self.options.track_distance)) <
			self.options.brgc_hole_diameter / 2):
			inkex.errormsg("Innermost encoder smaller than the center hole!")
		else:
			segments = self.drawGrayEncoder(
				line_style, self.options.bits,
				self.options.encoder_diameter,
				self.options.track_width,
				self.options.track_distance)
			for item in segments:
				self.addElement('path', group, item)

		self.drawCommonCircles(group, diameter, hole_diameter)

	def effectStgc(self, group, line_style, diameter, hole_diameter):

		if ((self.options.stgc_encoder_diameter / 2) -
			self.options.stgc_track_width < self.options.stgc_hole_diameter / 2):
			inkex.errormsg("Encoder smaller than the center hole!")
		elif not self.validSTGrayEncoder(self.options.cutouts, self.options.sensors):
			inkex.errormsg("Too many cutouts compared to number of sensors!")
		else:
			segments = self.drawSTGrayEncoder(line_style, self.options.cutouts,
				self.options.sensors, self.options.stgc_encoder_diameter,
				self.options.stgc_track_width)
			for item in segments:
				self.addElement('path', group, item)

		self.drawCommonCircles(group, diameter, hole_diameter)

	def effectRotaryEnc(self, group, line_style, diameter, hole_diameter):

		# Angle of one single segment
		segment_angle = 360.0 / (self.options.segments * 2)

		for segment_number in range(0, self.options.segments):

			angle = segment_number * (segment_angle * 2)

			if (self.options.outer_encoder_width > 0 and
				self.options.outer_encoder_diameter > 0 and
				self.options.outer_encoder_diameter / 2 >
				self.options.outer_encoder_width):

				segment = self.drawSegment(line_style, angle,
					segment_angle,
					self.options.outer_encoder_diameter,
					self.options.outer_encoder_width)
				self.addElement('path', group, segment)

			# If the inner encoder diameter is something else than 0; create it
			if (self.options.outer_encoder_width > 0 and
				self.options.inner_encoder_diameter > 0 and
				self.options.inner_encoder_diameter / 2 >
				self.options.inner_encoder_width):

				# The inner encoder must be half an encoder segment ahead of the outer one
				segment = self.drawSegment(
					line_style, angle + (segment_angle / 2), segment_angle,
					self.options.inner_encoder_diameter,
					self.options.inner_encoder_width)

				self.addElement('path', group, segment)

		self.drawCommonCircles(group, diameter, hole_diameter)

	def effectBitmapEnc(self, group, line_style, diameter, hole_diameter):

		bits = self.options.bm_bits
		bm_segments = len(bits)
		# Angle of one single segment
		segment_angle = 360.0 / bm_segments

		for segment_number in range(0, bm_segments):

			angle = segment_number * segment_angle

			if (self.options.bm_outer_encoder_width > 0 and
				self.options.bm_outer_encoder_diameter > 0 and
				self.options.bm_outer_encoder_diameter >
				self.options.bm_outer_encoder_width):

				self.drawLabel(group,
					angle, segment_angle,
					self.options.bm_diameter,
					segment_number)
				# Drawing only the black segments
				if (bits[segment_number] == '1'):
					segment = self.drawSegment(
						line_style, angle,
						segment_angle,
						self.options.bm_outer_encoder_diameter,
						self.options.bm_outer_encoder_width)

					self.addElement('path', group, segment)

		self.drawCommonCircles(group, diameter, hole_diameter)

	def effect(self):

		# Group to put all the elements in, center set in the middle of the view
		group = inkex.etree.SubElement(self.current_layer, 'g', {
			inkex.addNS('label', 'inkscape'): 'Encoder disk',
			'transform': 'translate' + str(self.view_center)
		})

		# Line style for the encoder segments
		line_style = {
			'stroke': 'white',
			'stroke-width': '0',
			'fill': 'black'
		}

		if self.options.tab == "\"brgc\"":
			self.effectBrgc(group, line_style,
			self.options.brgc_diameter,
			self.options.brgc_hole_diameter)

		if self.options.tab == "\"stgc\"":
			self.effectStgc(group, line_style,
			self.options.stgc_diameter,
			self.options.stgc_hole_diameter)

		if self.options.tab == "\"rotary_enc\"":
			self.effectRotaryEnc(group, line_style,
			self.options.diameter,
			self.options.hole_diameter)

		if self.options.tab == "\"bitmap_enc\"":
			self.effectBitmapEnc(group, line_style,
			self.options.bm_diameter,
			self.options.bm_hole_diameter)


if __name__ == '__main__':
	# Run the effect
	effect = EncoderDiskGenerator()
	effect.affect()