path: root/share/extensions/polyhedron_3d.py

#!/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()