diff options
Diffstat (limited to 'share/extensions/polyhedron_3d.py')
| -rwxr-xr-x | share/extensions/polyhedron_3d.py | 389 |
1 files changed, 389 insertions, 0 deletions
diff --git a/share/extensions/polyhedron_3d.py b/share/extensions/polyhedron_3d.py new file mode 100755 index 0000000..ef91f87 --- /dev/null +++ b/share/extensions/polyhedron_3d.py @@ -0,0 +1,389 @@ +#!/usr/bin/env python +# coding=utf-8 +# +# Copyright (C) 2007 John Beard john.j.beard@gmail.com +# +# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +""" +This extension draws 3d objects from a Wavefront .obj 3D file stored in a local folder +Many settings for appearance, lighting, rotation, etc are available. + + ^y + | + __--``| |_--``| __-- + __--`` | __--``| |_--`` + | z | | |_--``| + | <----|--------|-----_0-----|---------------- + | | |_--`` | | + | __--`` <-``| |_--`` + |__--`` x |__--``| + IMAGE PLANE SCENE| + | + + Vertices are given as "v" followed by three numbers (x,y,z). + All files need a vertex list + v x.xxx y.yyy z.zzz + + Faces are given by a list of vertices + (vertex 1 is the first in the list above, 2 the second, etc): + f 1 2 3 + + Edges are given by a list of vertices. These will be broken down + into adjacent pairs automatically. + l 1 2 3 + + Faces are rendered according to the painter's algorithm and perhaps + back-face culling, if selected. The parameter to sort the faces by + is user-selectable between max, min and average z-value of the vertices +""" + +import os +from math import acos, cos, floor, pi, sin, sqrt + +import inkex +from inkex.utils import pairwise +from inkex import Group, Circle +from inkex.paths import Move, Line + +try: + import numpy +except: + numpy = None + +def draw_circle(r, cx, cy, width, fill, name, parent): + """Draw an SVG circle""" + circle = parent.add(Circle(cx=str(cx), cy=str(cy), r=str(r))) + circle.style = {'stroke': '#000000', 'stroke-width': str(width), 'fill': fill} + circle.label = name + + +def draw_line(x1, y1, x2, y2, width, name, parent): + elem = parent.add(inkex.PathElement()) + elem.style = {'stroke': '#000000', 'stroke-width': str(width), 'fill': 'none', + 'stroke-linecap': 'round'} + elem.set('inkscape:label', name) + elem.path = [Move(x1, y1), Line(x2, y2)] + +def draw_poly(pts, face, st, name, parent): + """Draw polygone""" + style = {'stroke': '#000000', 'stroke-width': str(st.th), 'stroke-linejoin': st.linejoin, + 'stroke-opacity': st.s_opac, 'fill': st.fill, 'fill-opacity': st.f_opac} + path = inkex.Path() + for facet in face: + if not path: # for first point + path.append(Move(pts[facet - 1][0], -pts[facet - 1][1])) + else: + path.append(Line(pts[facet - 1][0], -pts[facet - 1][1])) + path.close() + + poly = parent.add(inkex.PathElement()) + poly.label = name + poly.style = style + poly.path = path + + +def draw_edges(edge_list, pts, st, parent): + for edge in edge_list: # for every edge + pt_1 = pts[edge[0] - 1][0:2] # the point at the start + pt_2 = pts[edge[1] - 1][0:2] # the point at the end + name = 'Edge' + str(edge[0]) + '-' + str(edge[1]) + draw_line(pt_1[0], -pt_1[1], pt_2[0], -pt_2[1], st.th, name, parent) + + +def draw_faces(faces_data, pts, obj, shading, fill_col, st, parent): + for face in faces_data: # for every polygon that has been sorted + if shading: + st.fill = get_darkened_colour(fill_col, face[1] / pi) # darken proportionally to angle to lighting vector + else: + st.fill = get_darkened_colour(fill_col, 1) # do not darken colour + + face_no = face[3] # the number of the face to draw + draw_poly(pts, obj.fce[face_no], st, 'Face:' + str(face_no), parent) + + +def get_darkened_colour(rgb, factor): + """return a hex triplet of colour, reduced in lightness 0.0-1.0""" + return '#' + "%02X" % floor(factor * rgb[0]) \ + + "%02X" % floor(factor * rgb[1]) \ + + "%02X" % floor(factor * rgb[2]) # make the colour string + + +def make_rotation_log(options): + """makes a string recording the axes and angles of each rotation, so an object can be repeated""" + return options.r1_ax + str('%.2f' % options.r1_ang) + ':' + \ + options.r2_ax + str('%.2f' % options.r2_ang) + ':' + \ + options.r3_ax + str('%.2f' % options.r3_ang) + ':' + \ + options.r1_ax + str('%.2f' % options.r4_ang) + ':' + \ + options.r2_ax + str('%.2f' % options.r5_ang) + ':' + \ + options.r3_ax + str('%.2f' % options.r6_ang) + +def normalise(vector): + """return the unit vector pointing in the same direction as the argument""" + length = sqrt(numpy.dot(vector, vector)) + return numpy.array(vector) / length + +def get_normal(pts, face): + """normal vector for the plane passing though the first three elements of face of pts""" + return numpy.cross( + (numpy.array(pts[face[0] - 1]) - numpy.array(pts[face[1] - 1])), + (numpy.array(pts[face[0] - 1]) - numpy.array(pts[face[2] - 1])), + ).flatten() + +def get_unit_normal(pts, face, cw_wound): + """ + Returns the unit normal for the plane passing through the + first three points of face, taking account of winding + """ + # if it is clockwise wound, reverse the vector direction + winding = -1 if cw_wound else 1 + return winding * normalise(get_normal(pts, face)) + +def rotate(matrix, rads, axis): + """choose the correct rotation matrix to use""" + if axis == 'x': + trans_mat = numpy.array([ + [1, 0, 0], [0, cos(rads), -sin(rads)], [0, sin(rads), cos(rads)]]) + elif axis == 'y': + trans_mat = numpy.array([ + [cos(rads), 0, sin(rads)], [0, 1, 0], [-sin(rads), 0, cos(rads)]]) + elif axis == 'z': + trans_mat = numpy.array([ + [cos(rads), -sin(rads), 0], [sin(rads), cos(rads), 0], [0, 0, 1]]) + return numpy.matmul(trans_mat, matrix) + +class Style(object): # container for style information + def __init__(self, options): + self.th = options.th + self.fill = '#ff0000' + self.col = '#000000' + self.r = 2 + self.f_opac = str(options.f_opac / 100.0) + self.s_opac = str(options.s_opac / 100.0) + self.linecap = 'round' + self.linejoin = 'round' + + +class WavefrontObj(object): + """Wavefront based 3d object defined by the vertices and the faces (eg a polyhedron)""" + name = property(lambda self: self.meta.get('name', None)) + + def __init__(self, filename): + self.meta = { + 'name': os.path.basename(filename).rsplit('.', 1)[0] + } + self.vtx = [] + self.edg = [] + self.fce = [] + self._parse_file(filename) + + def _parse_file(self, filename): + if not os.path.isfile(filename): + raise IOError("Can't find wavefront object file {}".format(filename)) + with open(filename, 'r') as fhl: + for line in fhl: + self._parse_line(line.strip()) + + def _parse_line(self, line): + if line.startswith('#'): + if ':' in line: + name, value = line.split(':', 1) + self.meta[name.lower()] = value + elif line: + (kind, line) = line.split(None, 1) + kind_name = 'add_' + kind + if hasattr(self, kind_name): + getattr(self, kind_name)(line) + + @staticmethod + def _parse_numbers(line, typ=str): + # Ignore any slash options and always pick the first one + return [typ(v.split('/')[0]) for v in line.split()] + + def add_v(self, line): + """Add vertex from parsed line""" + vertex = self._parse_numbers(line, float) + if len(vertex) == 3: + self.vtx.append(vertex) + + def add_l(self, line): + """Add line from parsed line""" + vtxlist = self._parse_numbers(line, int) + # we need at least 2 vertices to make an edge + if len(vtxlist) > 1: + # we can have more than one vertex per line - get adjacent pairs + self.edg.append(pairwise(vtxlist)) + + def add_f(self, line): + """Add face from parsed line""" + vtxlist = self._parse_numbers(line, int) + # we need at least 3 vertices to make an edge + if len(vtxlist) > 2: + self.fce.append(vtxlist) + + def get_transformed_pts(self, trans_mat): + """translate vertex points according to the matrix""" + transformed_pts = [] + for vtx in self.vtx: + transformed_pts.append((numpy.matmul(trans_mat, numpy.array(vtx).T)).T.tolist()) + return transformed_pts + + def get_edge_list(self): + """make an edge vertex list from an existing face vertex list""" + edge_list = [] + for face in self.fce: + for j, edge in enumerate(face): + # Ascending order of certices (for duplicate detection) + edge_list.append(sorted([edge, face[(j + 1) % len(face)]])) + return [list(x) for x in sorted(set(tuple(x) for x in edge_list))] + +class Poly3D(inkex.GenerateExtension): + """Generate a polyhedron from a wavefront 3d model file""" + def add_arguments(self, pars): + pars.add_argument("--tab", default="object") + + # MODEL FILE SETTINGS + pars.add_argument("--obj", default='cube') + pars.add_argument("--spec_file", default='great_rhombicuboct.obj') + pars.add_argument("--cw_wound", type=inkex.Boolean, default=True) + pars.add_argument("--type", default='face') + # VEIW SETTINGS + pars.add_argument("--r1_ax", default="x") + pars.add_argument("--r2_ax", default="x") + pars.add_argument("--r3_ax", default="x") + pars.add_argument("--r4_ax", default="x") + pars.add_argument("--r5_ax", default="x") + pars.add_argument("--r6_ax", default="x") + pars.add_argument("--r1_ang", type=float, default=0.0) + pars.add_argument("--r2_ang", type=float, default=0.0) + pars.add_argument("--r3_ang", type=float, default=0.0) + pars.add_argument("--r4_ang", type=float, default=0.0) + pars.add_argument("--r5_ang", type=float, default=0.0) + pars.add_argument("--r6_ang", type=float, default=0.0) + pars.add_argument("--scl", type=float, default=100.0) + # STYLE SETTINGS + pars.add_argument("--show", type=self.arg_method('gen')) + pars.add_argument("--shade", type=inkex.Boolean, default=True) + pars.add_argument("--f_r", type=int, default=255) + pars.add_argument("--f_g", type=int, default=0) + pars.add_argument("--f_b", type=int, default=0) + pars.add_argument("--f_opac", type=int, default=100) + pars.add_argument("--s_opac", type=int, default=100) + pars.add_argument("--th", type=float, default=2) + pars.add_argument("--lv_x", type=float, default=1) + pars.add_argument("--lv_y", type=float, default=1) + pars.add_argument("--lv_z", type=float, default=-2) + pars.add_argument("--back", type=inkex.Boolean, default=False) + pars.add_argument("--z_sort", type=self.arg_method('z_sort'), default=self.z_sort_min) + + def get_filename(self): + """Get the filename for the spec file""" + if self.options.obj == 'from_file': + return self.options.spec_file + moddir = self.ext_path() + return os.path.join(moddir, 'Poly3DObjects', self.options.obj + '.obj') + + def generate(self): + if numpy is None: + raise inkex.AbortExtension("numpy is required.") + so = self.options + + obj = WavefrontObj(self.get_filename()) + + scale = self.svg.unittouu('1px') # convert to document units + st = Style(so) # initialise style + + # we will put all the rotations in the object name, so it can be repeated in + poly = Group.new(obj.name + ':' + make_rotation_log(so)) + (pos_x, pos_y) = self.svg.namedview.center + poly.transform.add_translate(pos_x, pos_y) + poly.transform.add_scale(scale) + + # TRANSFORMATION OF THE OBJECT (ROTATION, SCALE, ETC) + trans_mat = numpy.identity(3, float) # init. trans matrix as identity matrix + for i in range(1, 7): # for each rotation + axis = getattr(so, 'r{}_ax'.format(i)) + angle = getattr(so, 'r{}_ang'.format(i)) * pi / 180 + trans_mat = rotate(trans_mat, angle, axis) + # scale by linear factor (do this only after the transforms to reduce round-off) + trans_mat = trans_mat * so.scl + + # the points as projected in the z-axis onto the viewplane + transformed_pts = obj.get_transformed_pts(trans_mat) + so.show(obj, st, poly, transformed_pts) + return poly + + def gen_vtx(self, obj, st, poly, transformed_pts): + """Generate Vertex""" + for i, pts in enumerate(transformed_pts): + draw_circle(st.r, pts[0], pts[1], st.th, '#000000', 'Point' + str(i), poly) + + def gen_edg(self, obj, st, poly, transformed_pts): + """Generate edges""" + # we already have an edge list + edge_list = obj.edg + if obj.fce: + # we must generate the edge list from the faces + edge_list = obj.get_edge_list() + + draw_edges(edge_list, transformed_pts, st, poly) + + def gen_fce(self, obj, st, poly, transformed_pts): + """Generate face""" + so = self.options + # colour tuple for the face fill + fill_col = (so.f_r, so.f_g, so.f_b) + # unit light vector + lighting = normalise((so.lv_x, -so.lv_y, so.lv_z)) + # we have a face list + if obj.fce: + z_list = [] + + for i, face in enumerate(obj.fce): + # get the normal vector to the face + norm = get_unit_normal(transformed_pts, face, so.cw_wound) + # get the angle between the normal and the lighting vector + angle = acos(numpy.dot(norm, lighting)) + z_sort_param = so.z_sort(transformed_pts, face) + + # include all polygons or just the front-facing ones as needed + if so.back or norm[2] > 0: + # record the maximum z-value of the face and angle to + # light, along with the face ID and normal + z_list.append((z_sort_param, angle, norm, i)) + + z_list.sort(key=lambda x: x[0]) # sort by ascending sort parameter of the face + draw_faces(z_list, transformed_pts, obj, so.shade, fill_col, st, poly) + + else: # we cannot generate a list of faces from the edges without a lot of computation + raise inkex.AbortExtension("Face data not found.") + + @staticmethod + def z_sort_max(pts, face): + """returns the largest z_value of any point in the face""" + return max([pts[facet - 1][2] for facet in face]) + + @staticmethod + def z_sort_min(pts, face): + """returns the smallest z_value of any point in the face""" + return min([pts[facet - 1][2] for facet in face]) + + @staticmethod + def z_sort_cent(pts, face): + """returns the centroid z_value of any point in the face""" + return sum([pts[facet - 1][2] for facet in face]) / len(face) + +if __name__ == '__main__': + Poly3D().run() |