270 lines
13 KiB
Python
270 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
'''
|
|
Copyright (C) 2013 Carl Sorensen carl.d.sorensen@gmail.com
|
|
Derived from grid_cartesian.py copyright (C) 2007 John Beard john.j.beard@gmail.com
|
|
|
|
|
|
##This extension allows you to draw a two-point perspective grid in Inkscape.
|
|
##There is a wide range of options including subdivision, subsubdivions
|
|
##and angles of the triangular axes.
|
|
##Custom line widths are also possible.
|
|
##All elements are grouped with similar elements (eg all x-subdivs)
|
|
|
|
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 2 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, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
'''
|
|
|
|
import inkex
|
|
from math import *
|
|
from lxml import etree
|
|
|
|
def draw_SVG_line(x1, y1, x2, y2, width, stroke, name, parent):
|
|
style = { 'stroke': stroke, 'stroke-width':str(width), 'fill': 'none' }
|
|
line_attribs = {'style':str(inkex.Style(style)),
|
|
inkex.addNS('label','inkscape'):name,
|
|
'd':'M '+str(x1)+','+str(y1)+' L '+str(x2)+','+str(y2)}
|
|
etree.SubElement(parent, inkex.addNS('path','svg'), line_attribs )
|
|
|
|
def draw_SVG_rect(x,y,w,h, width, stroke, fill, name, parent):
|
|
style = { 'stroke': stroke, 'stroke-width':str(width), 'fill':fill}
|
|
rect_attribs = {'style':str(inkex.Style(style)),
|
|
inkex.addNS('label','inkscape'):name,
|
|
'x':str(x), 'y':str(y), 'width':str(w), 'height':str(h)}
|
|
etree.SubElement(parent, inkex.addNS('rect','svg'), rect_attribs )
|
|
|
|
def colorString(pickerColor):
|
|
longcolor = int(pickerColor)
|
|
if longcolor < 0:
|
|
longcolor = longcolor & 0xFFFFFFFF
|
|
return '#' + format(longcolor >> 8, '06X')
|
|
|
|
class Grid_Perspective(inkex.EffectExtension):
|
|
|
|
def add_arguments(self, pars):
|
|
pars.add_argument("--size_unit", default="", help="Units for geometry")
|
|
pars.add_argument("--width", type=int, default=500, help="Width of grid window")
|
|
pars.add_argument("--height", type=int, default=300, help="Height of grid window")
|
|
pars.add_argument("--p_divs", type=int, default=10, help="Number of divisions in perspective angle")
|
|
pars.add_argument("--horizon", type=float, default=150, help="Y coordinate of horizon")
|
|
pars.add_argument("--left_x", type=float, default=-250, help="X coordinate of left perspective point")
|
|
pars.add_argument("--right_x", type=float, default=750, help="X coordinate of right perspective point")
|
|
pars.add_argument("--div_th", type=float, default=2, help="Grid division line thickness")
|
|
pars.add_argument("--div_color", type=int, help="Grid division line color")
|
|
pars.add_argument("--border_th", type=float, default=3, help="Border Line thickness")
|
|
|
|
def EdgePoints(self,x0, y0, theta):
|
|
# find the intersection points of the line with the extended
|
|
# grid bounding box.
|
|
# Note that y is positive DOWN, not up
|
|
# Grid bounding box goes from (0,0) to (self.xmax, self.ymax)
|
|
theta_r = radians(theta)
|
|
if theta_r == 0:
|
|
return [[0,y0],[self.xmax,y0],
|
|
[-100, self.ymax], [self.xmax+100,0]]
|
|
r_bot = (self.ymax-y0)/sin(theta_r)
|
|
r_top = -y0/sin(theta_r)
|
|
r_left = -x0/cos(theta_r)
|
|
r_right = (self.xmax-x0)/cos(theta_r)
|
|
return [[0,y0+r_left*sin(theta_r)], # left
|
|
[self.xmax, y0+r_right*sin(theta_r)], # right
|
|
[x0+r_bot*cos(theta_r), self.ymax], #bottom
|
|
[x0+r_top*cos(theta_r), 0]] #top
|
|
|
|
def trimmed_coords(self, x1, y1, theta):
|
|
#find the start and end coordinates for a grid line
|
|
#starting at (x1, y1) with an angle of theta
|
|
border_points = self.EdgePoints(x1, y1, theta)
|
|
left = 0
|
|
right = 1
|
|
top = 3
|
|
bottom = 2
|
|
x=0
|
|
y=1
|
|
if theta > 0:
|
|
if border_points[left][y] < 0:
|
|
start_x = border_points[top][x]
|
|
start_y = border_points[top][y]
|
|
else:
|
|
start_x = border_points[left][x]
|
|
start_y = border_points[left][y]
|
|
if border_points[right][y] > self.ymax:
|
|
end_x = border_points[bottom][x]
|
|
end_y = border_points[bottom][y]
|
|
else:
|
|
end_x = border_points[right][x]
|
|
end_y = border_points[right][y]
|
|
else:
|
|
if border_points[left][y] > self.ymax:
|
|
start_x = border_points[bottom][x]
|
|
start_y = border_points[bottom][y]
|
|
else:
|
|
start_x = border_points[left][x]
|
|
start_y = border_points[left][y]
|
|
if border_points[right][y] < 0:
|
|
end_x = border_points[top][x]
|
|
end_y = border_points[top][y]
|
|
else:
|
|
end_x = border_points[right][x]
|
|
end_y = border_points[right][y]
|
|
return [[start_x,start_y],[end_x, end_y]]
|
|
|
|
def drawAngledGridLine (self, x1, y1, theta, thickness, color,
|
|
label, groupName):
|
|
end_points = self.trimmed_coords(x1, y1, theta)
|
|
x_start = end_points[0][0]
|
|
y_start = end_points[0][1]
|
|
x_end = end_points[1][0]
|
|
y_end = end_points[1][1]
|
|
|
|
if (x_start >= 0 and x_start <= self.xmax and
|
|
y_start >= 0 and y_start <= self.ymax and
|
|
x_end >= 0 and x_end <= self.xmax and
|
|
y_end >= 0 and y_end <= self.ymax):
|
|
draw_SVG_line(x_start, y_start,
|
|
x_end, y_end,
|
|
thickness, colorString(color), label, groupName)
|
|
|
|
def perspective_intersection(self, left_theta, right_theta):
|
|
if right_theta == 0 or left_theta == 0 or left_theta == right_theta:
|
|
return -100 # outside of bounding box
|
|
r=(self.right_x - self.left_x)/(sin(right_theta)/tan(left_theta)-cos(right_theta))
|
|
y_int = self.horizon + r*sin(right_theta)
|
|
if y_int < 0 or y_int > self.ymax :
|
|
return -100 #above or below bounding box
|
|
return self.right_x + r*cos(right_theta)
|
|
|
|
def effect(self):
|
|
|
|
#find the pixel dimensions of the overall grid
|
|
self.ymax = self.svg.unittouu(str(self.options.height)+self.options.size_unit)
|
|
self.xmax = self.svg.unittouu(str(self.options.width)+self.options.size_unit)
|
|
self.horizon = self.svg.unittouu(str(self.options.horizon)+self.options.size_unit)
|
|
self.left_x = self.svg.unittouu(str(self.options.left_x)+self.options.size_unit)
|
|
self.right_x = self.svg.unittouu(str(self.options.right_x)+self.options.size_unit)
|
|
|
|
|
|
# Embed grid in group
|
|
#Put in in the centre of the current view
|
|
t = 'translate(' + str( self.svg.namedview.center[0]- self.xmax/2.0) + ',' + \
|
|
str( self.svg.namedview.center[1]- self.ymax/2.0) + ')'
|
|
g_attribs = {inkex.addNS('label','inkscape'):'Grid_Perspective:Size' + \
|
|
str( self.xmax)+'x'+str(self.ymax) +
|
|
':Horizon'+str(self.horizon) +
|
|
':LeftX'+str(self.left_x) +
|
|
':RightX'+str(self.right_x),
|
|
'transform':t }
|
|
grid = etree.SubElement(self.svg.get_current_layer(), 'g', g_attribs)
|
|
|
|
#Group for vertical gridlines
|
|
g_attribs = {inkex.addNS('label','inkscape'):'VerticalGridlines'}
|
|
gv = etree.SubElement(grid, 'g', g_attribs)
|
|
|
|
#Group for left point gridlines
|
|
g_attribs = {inkex.addNS('label','inkscape'):'LeftPointGridlines'}
|
|
glp = etree.SubElement(grid, 'g', g_attribs)
|
|
|
|
#Group for right point gridlines
|
|
g_attribs = {inkex.addNS('label','inkscape'):'RightPointGridlines'}
|
|
grp = etree.SubElement(grid, 'g', g_attribs)
|
|
|
|
draw_SVG_rect(0, 0, self.xmax, self.ymax, self.options.border_th,
|
|
colorString(self.options.div_color), 'none',
|
|
'Border', grid) #border rectangle
|
|
|
|
|
|
# Calculate the extreme angles for the left and right points
|
|
if self.horizon < 0 :
|
|
left_theta_min = atan((self.horizon-0)/(0-self.right_x))
|
|
left_theta_max = atan((self.ymax - self.horizon)/
|
|
(0-self.left_x))
|
|
right_theta_min = atan((0-self.horizon)/
|
|
(self.left_x-self.xmax))
|
|
right_theta_max = atan((self.horizon - self.ymax)/
|
|
(self.right_x - self.xmax ))
|
|
elif self.horizon < self.ymax :
|
|
left_theta_min = atan((self.horizon-0)/(self.left_x-0))
|
|
left_theta_max = atan((self.ymax - self.horizon)/
|
|
(0-self.left_x))
|
|
right_theta_min = atan((self.horizon-0)/
|
|
(self.right_x-self.xmax))
|
|
right_theta_max = atan((self.horizon - self.ymax)/
|
|
(self.right_x - self.xmax ))
|
|
else:
|
|
left_theta_min = atan((self.horizon-0)/(self.left_x-0))
|
|
left_theta_max = atan((self.ymax - self.horizon)/
|
|
(0-self.right_x))
|
|
right_theta_min = atan((self.horizon-0)/
|
|
(self.right_x-self.xmax))
|
|
right_theta_max = atan((self.horizon - self.ymax)/
|
|
(self.left_x - self.xmax ))
|
|
|
|
left_dtheta = (left_theta_max - left_theta_min)/float(self.options.p_divs)
|
|
|
|
right_dtheta = (right_theta_max - right_theta_min)/float(self.options.p_divs)
|
|
mid_index = self.options.p_divs/2
|
|
left_mid_theta = left_theta_min + mid_index * left_dtheta
|
|
right_mid_theta = right_theta_min + mid_index * right_dtheta
|
|
|
|
|
|
#DO THE PERSPECTIVE DIVISONS========================================
|
|
for i in range(0,self.options.p_divs+1):
|
|
left_theta = left_theta_min + i * left_dtheta
|
|
right_theta = right_theta_min + i * right_dtheta
|
|
self.drawAngledGridLine(self.left_x, self.horizon,
|
|
degrees(left_theta),
|
|
self.options.div_th,
|
|
self.options.div_color,
|
|
'LeftDivPersp'+str(i),
|
|
glp)
|
|
self.drawAngledGridLine(self.right_x, self.horizon,
|
|
degrees(right_theta),
|
|
self.options.div_th,
|
|
self.options.div_color,
|
|
'RightDivPersp'+str(i),
|
|
grp)
|
|
intersection = self.perspective_intersection(left_theta,
|
|
right_theta_max - i * right_dtheta)
|
|
if intersection > 0 and intersection < self.xmax:
|
|
draw_SVG_line(intersection, 0,
|
|
intersection, self.ymax,
|
|
self.options.div_th,
|
|
colorString(self.options.div_color),
|
|
'VerticalDiv'+str(i), gv)
|
|
comment = """
|
|
intersection = self.perspective_intersection(left_theta, right_mid_theta)
|
|
if intersection > 0 and intersection < self.xmax:
|
|
draw_SVG_line(intersection, 0,
|
|
intersection, self.ymax,
|
|
self.options.div_th,
|
|
colorString(self.options.div_color),
|
|
'VerticalDiv'+str(i), gv)
|
|
intersection = self.perspective_intersection(left_theta, right_theta)
|
|
if intersection > 0 and intersection < self.xmax:
|
|
draw_SVG_line(intersection, 0,
|
|
intersection, self.ymax,
|
|
self.options.div_th,
|
|
colorString(self.options.div_color),
|
|
'VerticalDiv'+str(i), gv)
|
|
"""
|
|
|
|
intersection = self.perspective_intersection(left_mid_theta, right_mid_theta)
|
|
if intersection > 0 and intersection < self.xmax:
|
|
draw_SVG_line(intersection, 0,
|
|
intersection, self.ymax,
|
|
self.options.div_th,
|
|
colorString(self.options.div_color),
|
|
'VerticalDiv'+str(i), gv)
|
|
|
|
if __name__ == '__main__':
|
|
Grid_Perspective().run() |