Classes
class	Style
class	Obj
class	Poly_3D
class	Poly_3DBasicTest
Functions
def	get_filename
def	objfile
def	get_obj_data
def	draw_SVG_dot
def	draw_SVG_line
def	draw_SVG_poly
def	draw_edges
def	draw_faces
def	get_darkened_colour
def	make_rotation_log
def	get_angle
def	length
def	normalise
def	get_normal
def	get_unit_normal
def	rotate
def	rot_z
def	rot_y
def	rot_x
def	get_transformed_pts
def	get_max_z
def	get_min_z
def	get_cent_z
def	get_z_sort_param
def	remove_duplicates
def	make_edge_list
def	__init__
def	__init__
def	set_type
Variables
	_ = gettext.gettext
tuple	e = Poly_3D()
	th
	fill
	col
	r
	f_opac
	s_opac
	linecap
	linejoin
	vtx
	edg
	fce
	name
	type

Function Documentation

def polyhedron_3d::__init__	(	self,
		options
	)

Definition at line 308 of file polyhedron_3d.py.

00309                               :
00310         self.th = options.th
00311         self.fill= '#ff0000'
00312         self.col = '#000000'
00313         self.r = 2
00314         self.f_opac = str(options.f_opac/100.0)
00315         self.s_opac = str(options.s_opac/100.0)
00316         self.linecap = 'round'
00317         self.linejoin = 'round'

def polyhedron_3d::__init__ ( self )

Definition at line 320 of file polyhedron_3d.py.

00321                       :
00322         self.vtx = []
00323         self.edg = []
00324         self.fce = []
00325         self.name=''

def polyhedron_3d::draw_edges	(	edge_list,
		pts,
		st,
		parent
	)

Definition at line 165 of file polyhedron_3d.py.

00166                                             :
00167     for edge in edge_list:#for every edge
00168         pt_1 = pts[ edge[0]-1 ][0:2] #the point at the start
00169         pt_2 = pts[ edge[1]-1 ][0:2] #the point at the end
00170         name = 'Edge'+str(edge[0])+'-'+str(edge[1])
00171         draw_SVG_line(pt_1,pt_2,st, name, parent)#plot edges

def polyhedron_3d::draw_faces	(	faces_data,
		pts,
		obj,
		shading,
		fill_col,
		st,
		parent
	)

Definition at line 172 of file polyhedron_3d.py.

00172                                                                    :          
00173     for face in faces_data:#for every polygon that has been sorted
00174         if shading:
00175             st.fill = get_darkened_colour(fill_col, face[1]/pi)#darken proportionally to angle to lighting vector
00176         else:
00177             st.fill = get_darkened_colour(fill_col, 1)#do not darken colour
00178                           
00179         face_no = face[3]#the number of the face to draw
00180         draw_SVG_poly(pts, obj.fce[ face_no ], st, 'Face:'+str(face_no), parent)
00181

def polyhedron_3d::draw_SVG_dot	(	cx,
		cy,
		st,
		name,
		parent
	)

Definition at line 135 of file polyhedron_3d.py.

00136                                             :
00137     style = { 'stroke': '#000000', 'stroke-width':str(st.th), 'fill': st.fill, 'stroke-opacity':st.s_opac, 'fill-opacity':st.f_opac}
00138     circ_attribs = {'style':simplestyle.formatStyle(style),
00139                     inkex.addNS('label','inkscape'):name,
00140                     'r':str(st.r),
00141                     'cx':str(cx), 'cy':str(-cy)}
00142     inkex.etree.SubElement(parent, inkex.addNS('circle','svg'), circ_attribs )

def polyhedron_3d::draw_SVG_line	(	x1,
		y1,
		x2,
		y2,
		st,
		name,
		parent
	)

Definition at line 143 of file polyhedron_3d.py.

00144                                                       :
00145     style = { 'stroke': '#000000', 'stroke-width':str(st.th), 'stroke-linecap':st.linecap}
00146     line_attribs = {'style':simplestyle.formatStyle(style),
00147                     inkex.addNS('label','inkscape'):name,
00148                     'd':'M '+str(x1)+','+str(-y1)+' L '+str(x2)+','+str(-y2)}
00149     inkex.etree.SubElement(parent, inkex.addNS('path','svg'), line_attribs )

def polyhedron_3d::draw_SVG_poly	(	pts,
		face,
		st,
		name,
		parent
	)

Definition at line 150 of file polyhedron_3d.py.

00151                                               :
00152     style = { 'stroke': '#000000', 'stroke-width':str(st.th), 'stroke-linejoin':st.linejoin, \
00153               'stroke-opacity':st.s_opac, 'fill': st.fill, 'fill-opacity':st.f_opac}   
00154     for i in range(len(face)):
00155         if i == 0:#for first point
00156             d = 'M'#move to
00157         else:
00158             d = d + 'L'#line to
00159         d = d+ str(pts[face[i]-1][0]) + ',' + str(-pts[face[i]-1][1])#add point
00160     d = d + 'z' #close the polygon
00161     
00162     line_attribs = {'style':simplestyle.formatStyle(style),
00163                     inkex.addNS('label','inkscape'):name,'d': d}
00164     inkex.etree.SubElement(parent, inkex.addNS('path','svg'), line_attribs )

def polyhedron_3d::get_angle	(	vector1,
		vector2
	)

Definition at line 198 of file polyhedron_3d.py.

00198                                  : #returns the angle between two vectors
00199     return acos( dot(vector1, vector2) )
00200

def polyhedron_3d::get_cent_z	(	pts,
		face
	)

Definition at line 268 of file polyhedron_3d.py.

00268                          : #returns the centroid z_value of any point in the face
00269     sum = 0
00270     for i in range(len(face)):
00271             sum += pts[ face[i]-1 ][2]
00272     return sum/len(face)
00273

def polyhedron_3d::get_darkened_colour	(	r,
		g,
		b,
		factor
	)

Definition at line 182 of file polyhedron_3d.py.

00183                                          :
00184 #return a hex triplet of colour, reduced in lightness proportionally to a value between 0 and 1
00185     return  '#' + "%02X" % floor( factor*r ) \
00186                 + "%02X" % floor( factor*g ) \
00187                 + "%02X" % floor( factor*b ) #make the colour string

def polyhedron_3d::get_filename ( self_options )

Definition at line 64 of file polyhedron_3d.py.

Referenced by Inkscape::UI::Widget::PrefFileButton::onFileChanged(), Inkscape::UI::Dialog::FileOpenDialogImplGtk::show(), and Inkscape::UI::Dialog::FileSaveDialogImplGtk::updateNameAndExtension().

00065                               :
00066         if self_options.obj == 'from_file':
00067             file = self_options.spec_file
00068         else:
00069             file = self_options.obj + '.obj'
00070             
00071         return file

def polyhedron_3d::get_max_z	(	pts,
		face
	)

Definition at line 254 of file polyhedron_3d.py.

00254                         : #returns the largest z_value of any point in the face
00255     max_z = pts[ face[0]-1 ][2]
00256     for i in range(1, len(face)):
00257         if pts[ face[0]-1 ][2] >= max_z:
00258             max_z = pts[ face[0]-1 ][2]
00259     return max_z
00260

def polyhedron_3d::get_min_z	(	pts,
		face
	)

Definition at line 261 of file polyhedron_3d.py.

00261                         : #returns the smallest z_value of any point in the face
00262     min_z = pts[ face[0]-1 ][2]
00263     for i in range(1, len(face)):
00264         if pts[ face[i]-1 ][2] <= min_z:
00265             min_z = pts[ face[i]-1 ][2]
00266     return min_z
00267

def polyhedron_3d::get_normal	(	pts,
		face
	)

Definition at line 207 of file polyhedron_3d.py.

00207                           : #returns the normal vector for the plane passing though the first three elements of face of pts
00208     #n = pt[0]->pt[1] x pt[0]->pt[3]
00209     a = (array(pts[ face[0]-1 ]) - array(pts[ face[1]-1 ]))
00210     b = (array(pts[ face[0]-1 ]) - array(pts[ face[2]-1 ]))
00211     return cross(a,b).flatten()
00212

def polyhedron_3d::get_obj_data	(	obj,
		name
	)

Definition at line 82 of file polyhedron_3d.py.

00084 00085 00086 00087 00088 00089 00090 00091 00092 00093 00094 00095 00096 00097 00098 00099 00100 00101 00102 00103 00104 00105 00106 00107 00108 00109 00110 00111 00112 00113 00114 00115 00116 00117 00118 00119 00120 00121 00122 00123 00124 00125 00126 00127 00128 00129 00130 00131 00132 00133 00134

class="fragment">00083 : infile = open(objfile(name)) #regular expressions getname = '(.[nN]ame:\\s*)(.*)' floating = '([\-\+\\d*\.e]*)' #a possibly non-integer number, with +/- and exponent. getvertex = '(v\\s+)'+floating+'\\s+'+floating+'\\s+'+floating getedgeline = '(l\\s+)(.*)' getfaceline = '(f\\s+)(.*)' getnextint = '(\\d+)([/\\d]*)(.*)'#we need to deal with 123\343\123 or 123\\456 as equivalent to 123 (we are ignoring the other options in the obj file) for line in infile: if line[0]=='#': #we have a comment line m = re.search(getname, line) #check to see if this line contains a name if m: obj.name = m.group(2) #if it does, set the property elif line[0] == 'v': #we have a vertex (maybe) m = re.search(getvertex, line) #check to see if this line contains a valid vertex if m: #we have a valid vertex obj.vtx.append( [float(m.group(2)), float(m.group(3)), float(m.group(4)) ] ) elif line[0] == 'l': #we have a line (maybe) m = re.search(getedgeline, line) #check to see if this line begins 'l ' if m: #we have a line beginning 'l ' vtxlist = [] #buffer while line: m2 = re.search(getnextint, line) if m2: vtxlist.append( int(m2.group(1)) ) line = m2.group(3)#remainder else: line = None if len(vtxlist) > 1:#we need at least 2 vertices to make an edge for i in range (len(vtxlist)-1):#we can have more than one vertex per line - get adjacent pairs obj.edg.append( ( vtxlist[i], vtxlist[i+1] ) )#get the vertex pair between that vertex and the next elif line[0] == 'f': #we have a face (maybe) m = re.search(getfaceline, line) if m: #we have a line beginning 'f ' vtxlist = []#buffer while line: m2 = re.search(getnextint, line) if m2: vtxlist.append( int(m2.group(1)) ) line = m2.group(3)#remainder else: line = None if len(vtxlist) > 2: #we need at least 3 vertices to make an edge obj.fce.append(vtxlist) if obj.name == '':#no name was found, use filename, without extension (.obj) obj.name = name[0:-4] #RENDERING AND SVG OUTPUT FUNCTIONS

def polyhedron_3d::get_transformed_pts	(	vtx_list,
		trans_mat
	)

Definition at line 248 of file polyhedron_3d.py.

00248                                              :#translate the points according to the matrix
00249     transformed_pts = []
00250     for vtx in vtx_list:
00251         transformed_pts.append((trans_mat * mat(vtx).T).T.tolist()[0] )#transform the points at add to the list
00252     return transformed_pts
00253

def polyhedron_3d::get_unit_normal	(	pts,
		face,
		cw_wound
	)

Definition at line 213 of file polyhedron_3d.py.

00213                                         : #returns the unit normal for the plane passing through the first three points of face, taking account of winding
00214     if cw_wound:
00215         winding = -1 #if it is clockwise wound, reverse the vecotr direction
00216     else:
00217         winding = 1 #else leave alone
00218     
00219     return winding*normalise(get_normal(pts, face))
00220

def polyhedron_3d::get_z_sort_param	(	pts,
		face,
		method
	)

Definition at line 274 of file polyhedron_3d.py.

00274                                        : #returns the z-sorting parameter specified by 'method' ('max', 'min', 'cent')  
00275     z_sort_param = ''
00276     if  method == 'max':
00277         z_sort_param  = get_max_z(pts, face)
00278     elif method == 'min':
00279         z_sort_param  = get_min_z(pts, face)
00280     else:
00281         z_sort_param  = get_cent_z(pts, face)
00282     return z_sort_param
00283 
00284 #OBJ DATA MANIPULATION

def polyhedron_3d::length ( vector )

Definition at line 201 of file polyhedron_3d.py.

Referenced by SPText::_buildLayoutInput(), org::w3c::dom::DOMString::c_str(), org::siox::Siox::colorSignature(), Inkscape::LivePathEffect::LPEPathLength::doEffect_pwd2(), org::w3c::dom::io::dprintf(), Deflater::encodeDistStatic(), org::w3c::dom::xpath::TokenExecutor::execute(), get_offset_between_points(), Shape::initialiseEdgeData(), OpenURL(), Path::PositionToLength(), read_shortcuts_file(), CxxTest::Win32Gui::setCaption(), CxxTest::X11Gui::setWindowName(), snap_vector_midpoint(), sp_dyna_draw_apply(), sp_eraser_apply(), sp_svgview_goto_first(), sp_svgview_show_next(), sp_text_get_length(), sp_text_get_length_upto(), StrokeNormalize(), Box3D::VPDragger::updateTip(), and GrDragger::updateTip().

00201                   :#return the pythagorean length of a vector
00202     return sqrt(dot(vector,vector))
00203

def polyhedron_3d::make_edge_list ( face_list )

Definition at line 296 of file polyhedron_3d.py.

00296                              :#make an edge vertex list from an existing face vertex list
00297     edge_list = []
00298     for i in range(len(face_list)):#for every face
00299         edges = len(face_list[i]) #number of edges around that face
00300         for j in range(edges):#for every vertex in that face
00301             new_edge = [face_list[i][j], face_list[i][(j+1)%edges] ]
00302             new_edge.sort() #put in ascending order of vertices (to ensure we spot duplicates)
00303             edge_list.append( new_edge )#get the vertex pair between that vertex and the next
00304     
00305     return remove_duplicates(edge_list)
00306

def polyhedron_3d::make_rotation_log ( options )

Definition at line 188 of file polyhedron_3d.py.

00189                               :
00190 #makes a string recording the axes and angles of each roation, so an object can be repeated
00191     return   options.r1_ax+str('%.2f'%options.r1_ang)+':'+\
00192              options.r2_ax+str('%.2f'%options.r2_ang)+':'+\
00193              options.r3_ax+str('%.2f'%options.r3_ang)+':'+\
00194              options.r1_ax+str('%.2f'%options.r4_ang)+':'+\
00195              options.r2_ax+str('%.2f'%options.r5_ang)+':'+\
00196              options.r3_ax+str('%.2f'%options.r6_ang)
00197 
#MATHEMATICAL FUNCTIONS

def polyhedron_3d::normalise ( vector )

Definition at line 204 of file polyhedron_3d.py.

00204                      :#return the unit vector pointing in the same direction as the argument
00205     return vector / length(vector)
00206

def polyhedron_3d::objfile ( name )

Definition at line 72 of file polyhedron_3d.py.

00073                  :
00074     import os.path
00075     if __name__ == '__main__':
00076         filename = sys.argv[0]
00077     else:
00078         filename = __file__
00079     path = os.path.abspath(os.path.dirname(filename))
00080     path = os.path.join(path, 'Poly3DObjects', name)
00081     return path

def polyhedron_3d::remove_duplicates ( list )

Definition at line 285 of file polyhedron_3d.py.

00285                            :#removes the duplicates from a list
00286     list.sort()#sort the list
00287  
00288     last = list[-1]
00289     for i in range(len(list)-2, -1, -1):
00290         if last==list[i]:
00291             del list[i]
00292         else:
00293             last = list[i]
00294     return list
00295

def polyhedron_3d::rot_x	(	matrix,
		a
	)

Definition at line 242 of file polyhedron_3d.py.

00242                       :#rotate around the x-axis by a radians
00243     trans_mat = mat(array( [[   1    ,    0    ,    0   ],
00244                             [   0    ,  cos(a) ,-sin(a) ],
00245                             [   0    ,  sin(a) , cos(a) ]]))
00246     return trans_mat*matrix
00247

def polyhedron_3d::rot_y	(	matrix,
		a
	)

Definition at line 236 of file polyhedron_3d.py.

00236                       :#rotate around the y-axis by a radians
00237     trans_mat = mat(array( [[ cos(a) ,    0    , sin(a) ],
00238                             [   0    ,    1    ,    0   ],
00239                             [-sin(a) ,    0    , cos(a) ]]))
00240     return trans_mat*matrix
00241

def polyhedron_3d::rot_z	(	matrix,
		a
	)

Definition at line 230 of file polyhedron_3d.py.

00230                       :#rotate around the z-axis by a radians
00231     trans_mat = mat(array( [[ cos(a) , -sin(a) ,    0   ],
00232                             [ sin(a) ,  cos(a) ,    0   ],
00233                             [   0    ,    0    ,    1   ]]))
00234     return trans_mat*matrix
00235

def polyhedron_3d::rotate	(	matrix,
		angle,
		axis
	)

Definition at line 221 of file polyhedron_3d.py.

Referenced by Geom::detail::bezier_clipping::convex_hull(), NR::operator*(), rotate_degrees(), sp_selection_rotate_relative(), and NrRotateTest::testInverse().

00221                                  :#choose the correct rotation matrix to use
00222     if   axis == 'x':
00223         matrix = rot_x(matrix, angle)
00224     elif axis == 'y':
00225         matrix = rot_y(matrix, angle)
00226     elif axis == 'z':
00227         matrix = rot_z(matrix, angle)
00228     return matrix
00229

def polyhedron_3d::set_type	(	self,
		options
	)

Definition at line 326 of file polyhedron_3d.py.

00327                                :
00328         if options.type == 'face':
00329             if self.fce != []:
00330                 self.type = 'face'
00331             else:
00332                 inkex.errormsg(_('No face data found in specified file.'))
00333                 inkex.errormsg(_('Try selecting "Edge Specified" in the Model File tab.\n'))
00334                 self.type = 'error'
00335         else:
00336             if self.edg != []:
00337                 self.type = 'edge'
00338             else:
00339                 inkex.errormsg(_('No edge data found in specified file.'))
00340                 inkex.errormsg(_('Try selecting "Face Specified" in the Model File tab.\n'))
00341                 self.type = 'error'