separated primitives operators for export and import to their own python file.

2 files changed, 3 insertions, 1490 deletions

diff --git a/render_povray/__init__.py b/render_povray/__init__.py
index 74ab9795..8723af17 100644
--- a/render_povray/__init__.py
+++ b/render_povray/__init__.py
@@ -36,6 +36,7 @@ if "bpy" in locals():
     import importlib
     importlib.reload(ui)
     importlib.reload(render)
+    importlib.reload(primitives)
     importlib.reload(update_files)
 
 else:
@@ -59,6 +60,7 @@ else:
     from . import (
             ui,
             render,
+            primitives,
             update_files,
             )
 
diff --git a/render_povray/render.py b/render_povray/render.py
index f115a931..bb4bda6c 100644
--- a/render_povray/render.py
+++ b/render_povray/render.py
@@ -29,8 +29,7 @@ import random
 import platform#
 import subprocess#
 from bpy.types import(Operator)
-from bpy_extras.io_utils import ImportHelper
-from bpy_extras import object_utils
+
 
 from . import df3 # for smoke rendering
 ##############################SF###########################
@@ -5001,1491 +5000,3 @@ class RenderPovTexturePreview(Operator):
         #tex.extension="CLIP"
         return {'FINISHED'}
         
-#################################POV-Ray specific###############################
-
-# XXX This should really be in a separate file imho (primitives.py eg?)
-
-from bpy.props import (
-        StringProperty,
-        BoolProperty,
-        IntProperty,
-        FloatProperty,
-        FloatVectorProperty,
-        EnumProperty,
-        PointerProperty,
-        CollectionProperty,
-        )
-
-
-def pov_define_mesh(mesh, verts, edges, faces, name, hide_geometry=True):
-    if mesh is None:
-        mesh = bpy.data.meshes.new(name)
-    mesh.from_pydata(verts, edges, faces)
-    mesh.update()
-    mesh.validate(False)  # Set it to True to see debug messages (helps ensure you generate valid geometry).
-    if hide_geometry:
-        mesh.vertices.foreach_set("hide", [True] * len(mesh.vertices))
-        mesh.edges.foreach_set("hide", [True] * len(mesh.edges))
-        mesh.polygons.foreach_set("hide", [True] * len(mesh.polygons))
-    return mesh
-
-
-class POVRAY_OT_lathe_add(bpy.types.Operator):
-    bl_idname = "pov.addlathe"
-    bl_label = "Lathe"
-    bl_options = {'REGISTER','UNDO'}
-    bl_description = "adds lathe"
-
-
-    def execute(self, context):
-        layers=[False]*20
-        layers[0]=True
-        bpy.ops.curve.primitive_bezier_curve_add(location=(0, 0, 0),
-            rotation=(0, 0, 0), layers=layers)
-        ob=context.scene.objects.active
-        ob.name = ob.data.name = "PovLathe"
-        ob.pov.object_as='LATHE' 
-        bpy.ops.object.mode_set(mode='EDIT')
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.transform.rotate(value=-pi/2, axis=(0, 0, 1))
-        bpy.ops.object.mode_set(mode='OBJECT')
-        ob.pov.curveshape = "lathe"
-        bpy.ops.object.modifier_add(type='SCREW')
-        bpy.context.object.modifiers["Screw"].axis = 'Y'
-        bpy.context.object.modifiers["Screw"].show_render = False
-        return {'FINISHED'}
-
-
-        
-def pov_superellipsoid_define(context, op, ob):
-
-        if op:
-            mesh = None
-
-            u = op.se_u
-            v = op.se_v
-            n1 = op.se_n1
-            n2 = op.se_n2
-            edit = op.se_edit
-            se_param1 = n2 # op.se_param1
-            se_param2 = n1 # op.se_param2
-            
-        else:
-            assert(ob)
-            mesh = ob.data
-
-            u = ob.pov.se_u
-            v = ob.pov.se_v
-            n1 = ob.pov.se_n1
-            n2 = ob.pov.se_n2
-            edit = ob.pov.se_edit
-            se_param1 = ob.pov.se_param1
-            se_param2 = ob.pov.se_param2
-            
-        verts = []
-        r=1
-        
-        stepSegment=360/v*pi/180
-        stepRing=pi/u
-        angSegment=0
-        angRing=-pi/2
-
-        step=0
-        for ring in range(0,u-1):
-            angRing += stepRing
-            for segment in range(0,v):
-                step += 1
-                angSegment += stepSegment
-                x = r*(abs(cos(angRing))**n1)*(abs(cos(angSegment))**n2)
-                if (cos(angRing) < 0 and cos(angSegment) > 0) or \
-                        (cos(angRing) > 0 and cos(angSegment) < 0):
-                    x = -x
-                y = r*(abs(cos(angRing))**n1)*(abs(sin(angSegment))**n2)
-                if (cos(angRing) < 0 and sin(angSegment) > 0) or \
-                        (cos(angRing) > 0 and sin(angSegment) < 0):
-                    y = -y
-                z = r*(abs(sin(angRing))**n1)
-                if sin(angRing) < 0:
-                    z = -z
-                x = round(x,4)
-                y = round(y,4)
-                z = round(z,4)
-                verts.append((x,y,z))
-        if edit == 'TRIANGLES':
-            verts.append((0,0,1))
-            verts.append((0,0,-1))
-            
-        faces = []
-        
-        for i in range(0,u-2):
-            m=i*v
-            for p in range(0,v):
-                if p < v-1:
-                    face=(m+p,1+m+p,v+1+m+p,v+m+p)
-                if p == v-1:
-                    face=(m+p,m,v+m,v+m+p)
-                faces.append(face)
-        if edit == 'TRIANGLES':
-            indexUp=len(verts)-2
-            indexDown=len(verts)-1
-            indexStartDown=len(verts)-2-v
-            for i in range(0,v):
-                if i < v-1:
-                    face=(indexDown,i,i+1)
-                    faces.append(face)
-                if i == v-1:
-                    face=(indexDown,i,0)
-                    faces.append(face)
-            for i in range(0,v):
-                if i < v-1:
-                    face=(indexUp,i+indexStartDown,i+indexStartDown+1)
-                    faces.append(face)
-                if i == v-1:
-                    face=(indexUp,i+indexStartDown,indexStartDown)
-                    faces.append(face)
-        if edit == 'NGONS':
-            face=[]
-            for i in range(0,v):
-                face.append(i)
-            faces.append(face)
-            face=[]
-            indexUp=len(verts)-1
-            for i in range(0,v):
-                face.append(indexUp-i)
-            faces.append(face)
-        mesh = pov_define_mesh(mesh, verts, [], faces, "SuperEllipsoid")
-
-        if not ob:
-            ob_base = object_utils.object_data_add(context, mesh, operator=None)
-            ob = ob_base.object
-            #engine = context.scene.render.engine what for?
-            ob = context.object
-            ob.name =  ob.data.name = "PovSuperellipsoid"
-            ob.pov.object_as = 'SUPERELLIPSOID'
-            ob.pov.se_param1 = n2
-            ob.pov.se_param2 = n1
-            
-            ob.pov.se_u = u
-            ob.pov.se_v = v
-            ob.pov.se_n1 = n1 
-            ob.pov.se_n2 = n2
-            ob.pov.se_edit = edit        
-
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-            
-class POVRAY_OT_superellipsoid_add(bpy.types.Operator):
-    bl_idname = "pov.addsuperellipsoid"
-    bl_label = "Add SuperEllipsoid"
-    bl_description = "Create a SuperEllipsoid"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    # XXX Keep it in sync with __init__'s RenderPovSettingsConePrimitive
-    #     If someone knows how to define operators' props from a func, I'd be delighted to learn it!
-    se_param1 = FloatProperty(
-            name="Parameter 1",
-            description="",
-            min=0.00, max=10.0, default=0.04)
-
-    se_param2 = FloatProperty(
-            name="Parameter 2",
-            description="",
-            min=0.00, max=10.0, default=0.04)
-            
-    se_u = IntProperty(name = "U-segments",
-                    description = "radial segmentation",
-                    default = 20, min = 4, max = 265)
-    se_v = IntProperty(name = "V-segments",
-                    description = "lateral segmentation",
-                    default = 20, min = 4, max = 265)
-    se_n1 = FloatProperty(name = "Ring manipulator",
-                      description = "Manipulates the shape of the Ring",
-                      default = 1.0, min = 0.01, max = 100.0)
-    se_n2 = FloatProperty(name = "Cross manipulator",
-                      description = "Manipulates the shape of the cross-section",
-                      default = 1.0, min = 0.01, max = 100.0)
-    se_edit = EnumProperty(items=[("NOTHING", "Nothing", ""),
-                                ("NGONS", "N-Gons", ""),
-                                ("TRIANGLES", "Triangles", "")],
-                        name="Fill up and down",
-                        description="",
-                        default='TRIANGLES')
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        return (engine in cls.COMPAT_ENGINES)
-        
-    def execute(self,context):
-        pov_superellipsoid_define(context, self, None)
-
-        self.report({'WARNING'}, "This native POV-Ray primitive won't have any vertex to show in edit mode")   
-
-        return {'FINISHED'}
-
-class POVRAY_OT_superellipsoid_update(bpy.types.Operator):
-    bl_idname = "pov.superellipsoid_update"
-    bl_label = "Update"
-    bl_description = "Update Superellipsoid"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.reveal()
-        bpy.ops.mesh.select_all(action='SELECT')
-        bpy.ops.mesh.delete(type='VERT')
-        bpy.ops.object.mode_set(mode="OBJECT")
-
-        pov_superellipsoid_define(context, None, context.object)
-
-        return {'FINISHED'}
-
-def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False):
-    faces = []
-    if not vertIdx1 or not vertIdx2:
-        return None
-    if len(vertIdx1) < 2 and len(vertIdx2) < 2:
-        return None
-    fan = False
-    if (len(vertIdx1) != len(vertIdx2)):
-        if (len(vertIdx1) == 1 and len(vertIdx2) > 1):
-            fan = True
-        else:
-            return None
-    total = len(vertIdx2)
-    if closed:
-        if flipped:
-            face = [
-                vertIdx1[0],
-                vertIdx2[0],
-                vertIdx2[total - 1]]
-            if not fan:
-                face.append(vertIdx1[total - 1])
-            faces.append(face)
-
-        else:
-            face = [vertIdx2[0], vertIdx1[0]]
-            if not fan:
-                face.append(vertIdx1[total - 1])
-            face.append(vertIdx2[total - 1])
-            faces.append(face)
-    for num in range(total - 1):
-        if flipped:
-            if fan:
-                face = [vertIdx2[num], vertIdx1[0], vertIdx2[num + 1]]
-            else:
-                face = [vertIdx2[num], vertIdx1[num],
-                    vertIdx1[num + 1], vertIdx2[num + 1]]
-            faces.append(face)
-        else:
-            if fan:
-                face = [vertIdx1[0], vertIdx2[num], vertIdx2[num + 1]]
-            else:
-                face = [vertIdx1[num], vertIdx2[num],
-                    vertIdx2[num + 1], vertIdx1[num + 1]]
-            faces.append(face)
-
-    return faces
-
-def power(a,b):
-    if a < 0:
-        return -((-a)**b)
-    return a**b
-    
-def supertoroid(R,r,u,v,n1,n2):
-    a = 2*pi/u
-    b = 2*pi/v
-    verts = []
-    faces = []
-    for i in range(u):
-        s = power(sin(i*a),n1)
-        c = power(cos(i*a),n1)
-        for j in range(v):
-            c2 = R+r*power(cos(j*b),n2)
-            s2 = r*power(sin(j*b),n2)
-            verts.append((c*c2,s*c2,s2))# type as a (mathutils.Vector(c*c2,s*c2,s2))?
-        if i > 0:
-            f = createFaces(range((i-1)*v,i*v),range(i*v,(i+1)*v),closed = True)
-            faces.extend(f)
-    f = createFaces(range((u-1)*v,u*v),range(v),closed=True)
-    faces.extend(f)
-    return verts, faces
-
-def pov_supertorus_define(context, op, ob):    
-        if op:
-            mesh = None
-            st_R = op.st_R
-            st_r = op.st_r
-            st_u = op.st_u
-            st_v = op.st_v
-            st_n1 = op.st_n1
-            st_n2 = op.st_n2
-            st_ie = op.st_ie
-            st_edit = op.st_edit
-
-        else:
-            assert(ob)
-            mesh = ob.data
-            st_R = ob.pov.st_major_radius
-            st_r = ob.pov.st_minor_radius
-            st_u = ob.pov.st_u
-            st_v = ob.pov.st_v
-            st_n1 = ob.pov.st_ring
-            st_n2 = ob.pov.st_cross
-            st_ie = ob.pov.st_ie
-            st_edit = ob.pov.st_edit
-            
-        if st_ie:
-            rad1 = (st_R+st_r)/2
-            rad2 = (st_R-st_r)/2
-            if rad2 > rad1:
-                [rad1,rad2] = [rad2,rad1]
-        else:
-            rad1 = st_R
-            rad2 = st_r
-            if rad2 > rad1:
-                rad1 = rad2
-        verts,faces = supertoroid(rad1,
-                                  rad2,
-                                  st_u,
-                                  st_v,
-                                  st_n1,
-                                  st_n2)
-        mesh = pov_define_mesh(mesh, verts, [], faces, "PovSuperTorus", True)
-        if not ob:
-            ob_base = object_utils.object_data_add(context, mesh, operator=None)
-
-            ob = ob_base.object
-            ob.pov.object_as = 'SUPERTORUS'
-            ob.pov.st_major_radius = st_R
-            ob.pov.st_minor_radius = st_r
-            ob.pov.st_u = st_u
-            ob.pov.st_v = st_v
-            ob.pov.st_ring = st_n1
-            ob.pov.st_cross = st_n2
-            ob.pov.st_ie = st_ie
-            ob.pov.st_edit = st_edit
-            
-class POVRAY_OT_supertorus_add(bpy.types.Operator):
-    bl_idname = "pov.addsupertorus"
-    bl_label = "Add Supertorus"
-    bl_description = "Create a SuperTorus"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}    
-    
-    st_R = FloatProperty(name = "big radius",
-                      description = "The radius inside the tube",
-                      default = 1.0, min = 0.01, max = 100.0)
-    st_r = FloatProperty(name = "small radius",
-                      description = "The radius of the tube",
-                      default = 0.3, min = 0.01, max = 100.0)
-    st_u = IntProperty(name = "U-segments",
-                    description = "radial segmentation",
-                    default = 16, min = 3, max = 265)
-    st_v = IntProperty(name = "V-segments",
-                    description = "lateral segmentation",
-                    default = 8, min = 3, max = 265)
-    st_n1 = FloatProperty(name = "Ring manipulator",
-                      description = "Manipulates the shape of the Ring",
-                      default = 1.0, min = 0.01, max = 100.0)
-    st_n2 = FloatProperty(name = "Cross manipulator",
-                      description = "Manipulates the shape of the cross-section",
-                      default = 1.0, min = 0.01, max = 100.0)
-    st_ie = BoolProperty(name = "Use Int.+Ext. radii",
-                      description = "Use internal and external radii",
-                      default = False)
-    st_edit = BoolProperty(name="",
-                        description="",
-                        default=False,
-                        options={'HIDDEN'})    
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        return (engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-        pov_supertorus_define(context, self, None)
-
-        self.report({'WARNING'}, "This native POV-Ray primitive won't have any vertex to show in edit mode")        
-        return {'FINISHED'}                        
-
-class POVRAY_OT_supertorus_update(bpy.types.Operator):
-    bl_idname = "pov.supertorus_update"
-    bl_label = "Update"
-    bl_description = "Update SuperTorus"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.reveal()
-        bpy.ops.mesh.select_all(action='SELECT')
-        bpy.ops.mesh.delete(type='VERT')
-        bpy.ops.object.mode_set(mode="OBJECT")
-
-        pov_supertorus_define(context, None, context.object)
-
-        return {'FINISHED'}
-#########################################################################################################
-class POVRAY_OT_loft_add(bpy.types.Operator):
-    bl_idname = "pov.addloft"
-    bl_label = "Add Loft Data"
-    bl_description = "Create a Curve data for Meshmaker"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-    
-    loft_n = IntProperty(name = "Segments",
-                    description = "Vertical segments",
-                    default = 16, min = 3, max = 720)
-    loft_rings_bottom = IntProperty(name = "Bottom",
-                    description = "Bottom rings",
-                    default = 5, min = 2, max = 100)
-    loft_rings_side = IntProperty(name = "Side",
-                    description = "Side rings",
-                    default = 10, min = 2, max = 100)
-    loft_thick = FloatProperty(name = "Thickness",
-                      description = "Manipulates the shape of the Ring",
-                      default = 0.3, min = 0.01, max = 1.0)
-    loft_r = FloatProperty(name = "Radius",
-                      description = "Radius",
-                      default = 1, min = 0.01, max = 10)
-    loft_height = FloatProperty(name = "Height",
-                      description = "Manipulates the shape of the Ring",
-                      default = 2, min = 0.01, max = 10.0)
-
-    def execute(self,context):
-        
-        props = self.properties
-        loftData = bpy.data.curves.new('Loft', type='CURVE')
-        loftData.dimensions = '3D'
-        loftData.resolution_u = 2
-        loftData.show_normal_face = False
-        n=props.loft_n
-        thick = props.loft_thick
-        side = props.loft_rings_side
-        bottom = props.loft_rings_bottom
-        h = props.loft_height
-        r = props.loft_r
-        distB = r/bottom
-        r0 = 0.00001
-        z = -h/2
-        print("New")
-        for i in range(bottom+1):
-            coords = []
-            angle = 0
-            for p in range(n):
-                x = r0*cos(angle)
-                y = r0*sin(angle)
-                coords.append((x,y,z))
-                angle+=pi*2/n
-            r0+=distB
-            nurbs = loftData.splines.new('NURBS')
-            nurbs.points.add(len(coords)-1)
-            for i, coord in enumerate(coords):
-                x,y,z = coord
-                nurbs.points[i].co = (x, y, z, 1)
-            nurbs.use_cyclic_u = True
-        for i in range(side):
-            z+=h/side
-            coords = []
-            angle = 0
-            for p in range(n):
-                x = r*cos(angle)
-                y = r*sin(angle)
-                coords.append((x,y,z))
-                angle+=pi*2/n
-            nurbs = loftData.splines.new('NURBS')
-            nurbs.points.add(len(coords)-1)
-            for i, coord in enumerate(coords):
-                x,y,z = coord
-                nurbs.points[i].co = (x, y, z, 1)
-            nurbs.use_cyclic_u = True
-        r-=thick
-        for i in range(side):
-            coords = []
-            angle = 0
-            for p in range(n):
-                x = r*cos(angle)
-                y = r*sin(angle)
-                coords.append((x,y,z))
-                angle+=pi*2/n
-            nurbs = loftData.splines.new('NURBS')
-            nurbs.points.add(len(coords)-1)
-            for i, coord in enumerate(coords):
-                x,y,z = coord
-                nurbs.points[i].co = (x, y, z, 1)
-            nurbs.use_cyclic_u = True
-            z-=h/side
-        z = (-h/2) + thick
-        distB = (r-0.00001)/bottom
-        for i in range(bottom+1):
-            coords = []
-            angle = 0
-            for p in range(n):
-                x = r*cos(angle)
-                y = r*sin(angle)
-                coords.append((x,y,z))
-                angle+=pi*2/n
-            r-=distB
-            nurbs = loftData.splines.new('NURBS')
-            nurbs.points.add(len(coords)-1)
-            for i, coord in enumerate(coords):
-                x,y,z = coord
-                nurbs.points[i].co = (x, y, z, 1)
-            nurbs.use_cyclic_u = True
-        ob = bpy.data.objects.new('Loft_shape', loftData)
-        scn = bpy.context.scene
-        scn.objects.link(ob)
-        scn.objects.active = ob
-        ob.select = True
-        ob.pov.curveshape = "loft"
-        return {'FINISHED'}
-
-class POVRAY_OT_plane_add(bpy.types.Operator):
-    bl_idname = "pov.addplane"
-    bl_label = "Plane"
-    bl_description = "Add Plane"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_plane_add(radius = 100000,layers=layers)
-        ob = context.object
-        ob.name = ob.data.name = 'PovInfinitePlane'
-        bpy.ops.object.mode_set(mode="EDIT")
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        bpy.ops.object.shade_smooth()
-        ob.pov.object_as = "PLANE"
-        return {'FINISHED'}
-        
-class POVRAY_OT_box_add(bpy.types.Operator):
-    bl_idname = "pov.addbox"
-    bl_label = "Box"
-    bl_description = "Add Box"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_cube_add(layers=layers)
-        ob = context.object
-        ob.name = ob.data.name = 'PovBox'
-        bpy.ops.object.mode_set(mode="EDIT")
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        ob.pov.object_as = "BOX"
-        return {'FINISHED'}
-
-class POVRAY_OT_cylinder_add(bpy.types.Operator):
-    bl_idname = "pov.addcylinder"
-    bl_label = "Cylinder"
-    bl_description = "Add Cylinder"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_cylinder_add(layers = layers)
-        ob = context.object
-        ob.name = ob.data.name = 'PovCylinder'
-        bpy.ops.object.mode_set(mode="EDIT")
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        ob.pov.object_as = "CYLINDER"
-
-        return {'FINISHED'}
-################################SPHERE##########################################
-def pov_sphere_define(context, op, ob, loc):
-        if op:
-            R = op.R
-
-        else:
-            assert(ob)
-            R = ob.pov.sphere_radius
-
-            #keep object rotation and location for the add object operator
-            obrot = ob.rotation_euler
-            #obloc = ob.location
-            obscale = ob.scale
-            
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.reveal()
-            bpy.ops.mesh.select_all(action='SELECT')
-            bpy.ops.mesh.delete(type='VERT')
-            bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, size=ob.pov.sphere_radius, location=loc, rotation=obrot)
-            #bpy.ops.transform.rotate(axis=obrot,constraint_orientation='GLOBAL')
-            bpy.ops.transform.resize(value=obscale)
-            #bpy.ops.transform.rotate(axis=obrot, proportional_size=1)
-            
-            
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-            #bpy.ops.transform.rotate(axis=obrot,constraint_orientation='GLOBAL')
-
-        if not ob:
-            bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, size=R, location=loc)
-            ob = context.object
-            ob.name =  ob.data.name = "PovSphere"
-            ob.pov.object_as = "SPHERE"
-            ob.pov.sphere_radius = R
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-class POVRAY_OT_sphere_add(bpy.types.Operator):
-    bl_idname = "pov.addsphere"
-    bl_label = "Sphere"
-    bl_description = "Add Sphere Shape"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    # XXX Keep it in sync with __init__'s torus Primitive
-    R = FloatProperty(name="Sphere radius",min=0.00, max=10.0, default=0.5) 
-    
-    imported_loc = FloatVectorProperty(
-        name="Imported Pov location",
-        precision=6, 
-        default=(0.0, 0.0, 0.0))
-    
-    def execute(self,context):
-        props = self.properties
-        R = props.R
-        ob = context.object
-        if ob:
-            if ob.pov.imported_loc:
-                LOC = ob.pov.imported_loc
-        else:
-            LOC = bpy.context.scene.cursor_location
-        pov_sphere_define(context, self, None, LOC)
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        return {'FINISHED'}
-        
-    # def execute(self,context):
-        # layers = 20*[False]
-        # layers[0] = True
-
-        # bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, radius=ob.pov.sphere_radius, layers=layers)
-        # ob = context.object
-        # bpy.ops.object.mode_set(mode="EDIT")
-        # self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 # "won't have any vertex to show in edit mode")
-        # bpy.ops.mesh.hide(unselected=False)
-        # bpy.ops.object.mode_set(mode="OBJECT")
-        # bpy.ops.object.shade_smooth()
-        # ob.pov.object_as = "SPHERE"
-        # ob.name = ob.data.name = 'PovSphere'
-        # return {'FINISHED'}
-class POVRAY_OT_sphere_update(bpy.types.Operator):
-    bl_idname = "pov.sphere_update"
-    bl_label = "Update"
-    bl_description = "Update Sphere"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-
-        pov_sphere_define(context, None, context.object,context.object.location)
-
-        return {'FINISHED'}        
-
-        
-####################################CONE#######################################
-def pov_cone_define(context, op, ob):
-    verts = []
-    faces = []
-    if op:
-        mesh = None
-        base = op.base
-        cap = op.cap
-        seg = op.seg
-        height = op.height
-    else:
-        assert(ob)
-        mesh = ob.data
-        base = ob.pov.cone_base_radius
-        cap = ob.pov.cone_cap_radius
-        seg = ob.pov.cone_segments
-        height = ob.pov.cone_height 
-
-    zc = height / 2
-    zb = -zc
-    angle = 2 * pi / seg
-    t = 0
-    for i in range(seg):
-        xb = base * cos(t)
-        yb = base * sin(t)
-        xc = cap * cos(t)
-        yc = cap * sin(t)
-        verts.append((xb, yb, zb))
-        verts.append((xc, yc, zc))
-        t += angle
-    for i in range(seg):
-        f = i * 2
-        if i == seg - 1:
-            faces.append([0, 1, f + 1, f])
-        else:
-            faces.append([f + 2, f + 3, f + 1, f])
-    if base != 0:
-        base_face = []
-        for i in range(seg - 1, -1, -1):
-            p = i * 2
-            base_face.append(p)
-        faces.append(base_face)
-    if cap != 0:
-        cap_face = []
-        for i in range(seg):
-            p = i * 2 + 1
-            cap_face.append(p)
-        faces.append(cap_face)
-
-    mesh = pov_define_mesh(mesh, verts, [], faces, "PovCone", True)
-    if not ob:
-        ob_base = object_utils.object_data_add(context, mesh, operator=None)
-        ob = ob_base.object
-        ob.pov.object_as = "CONE"
-        ob.pov.cone_base_radius = base
-        ob.pov.cone_cap_radius = cap
-        ob.pov.cone_height = height
-        ob.pov.cone_base_z = zb
-        ob.pov.cone_cap_z = zc
-
-
-class POVRAY_OT_cone_add(bpy.types.Operator):
-    bl_idname = "pov.cone_add"
-    bl_label = "Cone"
-    bl_description = "Add Cone"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    # XXX Keep it in sync with __init__'s RenderPovSettingsConePrimitive
-    #     If someone knows how to define operators' props from a func, I'd be delighted to learn it!
-    base = FloatProperty(
-        name = "Base radius", description = "The first radius of the cone",
-        default = 1.0, min = 0.01, max = 100.0)
-    cap = FloatProperty(
-        name = "Cap radius", description = "The second radius of the cone",
-        default = 0.3, min = 0.0, max = 100.0)
-    seg = IntProperty(
-        name = "Segments", description = "Radial segmentation of the proxy mesh",
-        default = 16, min = 3, max = 265)
-    height = FloatProperty(
-        name = "Height", description = "Height of the cone",
-        default = 2.0, min = 0.01, max = 100.0)
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        return (engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-        pov_cone_define(context, self, None)
-
-        self.report({'WARNING'}, "This native POV-Ray primitive won't have any vertex to show in edit mode")        
-        return {'FINISHED'}
-
-
-class POVRAY_OT_cone_update(bpy.types.Operator):
-    bl_idname = "pov.cone_update"
-    bl_label = "Update"
-    bl_description = "Update Cone"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.reveal()
-        bpy.ops.mesh.select_all(action='SELECT')
-        bpy.ops.mesh.delete(type='VERT')
-        bpy.ops.object.mode_set(mode="OBJECT")
-
-        pov_cone_define(context, None, context.object)
-
-        return {'FINISHED'}
-#########################################################################################################
-
-class POVRAY_OT_isosurface_box_add(bpy.types.Operator):
-    bl_idname = "pov.addisosurfacebox"
-    bl_label = "Isosurface Box"
-    bl_description = "Add Isosurface contained by Box"
-    bl_options = {'REGISTER', 'UNDO'}
-
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_cube_add(layers = layers)
-        ob = context.object
-        bpy.ops.object.mode_set(mode="EDIT")
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        ob.pov.object_as = "ISOSURFACE"
-        ob.pov.contained_by = 'box'
-        ob.name = 'Isosurface'
-        return {'FINISHED'}
-
-class POVRAY_OT_isosurface_sphere_add(bpy.types.Operator):
-    bl_idname = "pov.addisosurfacesphere"
-    bl_label = "Isosurface Sphere"
-    bl_description = "Add Isosurface contained by Sphere"
-    bl_options = {'REGISTER', 'UNDO'}
-
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4,layers=layers)
-        ob = context.object
-        bpy.ops.object.mode_set(mode="EDIT")
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        bpy.ops.object.shade_smooth()
-        ob.pov.object_as = "ISOSURFACE"
-        ob.pov.contained_by = 'sphere'
-        ob.name = 'Isosurface'
-        return {'FINISHED'}
-
-class POVRAY_OT_sphere_sweep_add(bpy.types.Operator):
-    bl_idname = "pov.addspheresweep"
-    bl_label = "Sphere Sweep"
-    bl_description = "Create Sphere Sweep along curve"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.curve.primitive_nurbs_curve_add(layers = layers)
-        ob = context.object
-        ob.name = ob.data.name = "PovSphereSweep"
-        ob.pov.curveshape = "sphere_sweep"
-        ob.data.bevel_depth = 0.02
-        ob.data.bevel_resolution = 4
-        ob.data.fill_mode = 'FULL'
-        #ob.data.splines[0].order_u = 4
-
-        return {'FINISHED'}
-
-class POVRAY_OT_blob_add(bpy.types.Operator):
-    bl_idname = "pov.addblobsphere"
-    bl_label = "Blob Sphere"
-    bl_description = "Add Blob Sphere"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    def execute(self,context):
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.object.metaball_add(type = 'BALL',layers = layers)
-        ob = context.object
-        ob.name = "Blob"
-        return {'FINISHED'}
-        
-
-class POVRAY_OT_rainbow_add(bpy.types.Operator):        
-    bl_idname = "pov.addrainbow"
-    bl_label = "Rainbow"
-    bl_description = "Add Rainbow"
-    bl_options = {'REGISTER', 'UNDO'}
-                      
-    def execute(self,context):
-        cam = context.scene.camera
-        bpy.ops.object.lamp_add(type='SPOT', radius=1) 
-        ob = context.object
-        ob.data.show_cone = False
-        ob.data.spot_blend = 0.5
-        ob.data.shadow_buffer_clip_end = 0 
-        ob.data.shadow_buffer_clip_start = 4*cam.location.length
-        ob.data.distance = cam.location.length
-        ob.data.energy = 0        
-        ob.name = ob.data.name = "PovRainbow"
-        ob.pov.object_as = "RAINBOW"
-    
-        #obj = context.object
-        bpy.ops.object.constraint_add(type='DAMPED_TRACK')
-
-
-
-        ob.constraints["Damped Track"].target = cam
-        ob.constraints["Damped Track"].track_axis = 'TRACK_NEGATIVE_Z'
-        ob.location = -cam.location
-
-        #refocus on the actual rainbow
-        bpy.context.scene.objects.active = ob
-        ob.select=True
-        
-        return {'FINISHED'}
-
-class POVRAY_OT_height_field_add(bpy.types.Operator, ImportHelper):
-    bl_idname = "pov.addheightfield"
-    bl_label = "Height Field"
-    bl_description = "Add Height Field "
-    bl_options = {'REGISTER', 'UNDO'}
-    
-    # XXX Keep it in sync with __init__'s hf Primitive
-    # filename_ext = ".png"
-    
-    # filter_glob = StringProperty(
-            # default="*.exr;*.gif;*.hdr;*.iff;*.jpeg;*.jpg;*.pgm;*.png;*.pot;*.ppm;*.sys;*.tga;*.tiff;*.EXR;*.GIF;*.HDR;*.IFF;*.JPEG;*.JPG;*.PGM;*.PNG;*.POT;*.PPM;*.SYS;*.TGA;*.TIFF",
-            # options={'HIDDEN'},
-            # )
-    quality = IntProperty(name = "Quality",
-                      description = "",
-                      default = 100, min = 1, max = 100)
-    hf_filename = StringProperty(maxlen = 1024)
-    
-    hf_gamma = FloatProperty(
-            name="Gamma",
-            description="Gamma",
-            min=0.0001, max=20.0, default=1.0)
-
-    hf_premultiplied = BoolProperty(
-            name="Premultiplied",
-            description="Premultiplied",
-            default=True)
-
-    hf_smooth = BoolProperty(
-            name="Smooth",
-            description="Smooth",
-            default=False)
-
-    hf_water = FloatProperty(
-            name="Water Level",
-            description="Wather Level",
-            min=0.00, max=1.00, default=0.0)
-
-    hf_hierarchy = BoolProperty(
-            name="Hierarchy",
-            description="Height field hierarchy",
-            default=True)
-    def execute(self,context):
-        props = self.properties
-        impath = bpy.path.abspath(self.filepath)
-        img = bpy.data.images.load(impath)
-        im_name = img.name
-        im_name, file_extension = os.path.splitext(im_name)
-        hf_tex = bpy.data.textures.new('%s_hf_image'%im_name, type = 'IMAGE')
-        hf_tex.image = img
-        mat = bpy.data.materials.new('Tex_%s_hf'%im_name)
-        hf_slot = mat.texture_slots.create(-1)
-        hf_slot.texture = hf_tex
-        layers = 20*[False]
-        layers[0] = True
-        quality = props.quality
-        res = 100/quality
-        w,h = hf_tex.image.size[:]
-        w = int(w/res)
-        h = int(h/res)
-        bpy.ops.mesh.primitive_grid_add(x_subdivisions=w, y_subdivisions=h,radius = 0.5,layers=layers)
-        ob = context.object
-        ob.name = ob.data.name = '%s'%im_name
-        ob.data.materials.append(mat)
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.noise(factor=1)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        
-        #needs a loop to select by index? 
-        #bpy.ops.object.material_slot_remove()
-        #material just left there for now
-       
-      
-        mat.texture_slots.clear(-1)
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        ob.pov.object_as = 'HEIGHT_FIELD'
-        ob.pov.hf_filename = impath
-        return {'FINISHED'}
-        
-        
-############################TORUS############################################
-def pov_torus_define(context, op, ob):
-        if op:
-            mas = op.mas
-            mis = op.mis
-            mar = op.mar
-            mir = op.mir
-        else:
-            assert(ob)
-            mas = ob.pov.torus_major_segments
-            mis = ob.pov.torus_minor_segments
-            mar = ob.pov.torus_major_radius
-            mir = ob.pov.torus_minor_radius
-            
-            #keep object rotation and location for the add object operator
-            obrot = ob.rotation_euler
-            obloc = ob.location
-            
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.reveal()
-            bpy.ops.mesh.select_all(action='SELECT')
-            bpy.ops.mesh.delete(type='VERT')
-            bpy.ops.mesh.primitive_torus_add(rotation = obrot, location = obloc, major_segments=mas, minor_segments=mis,major_radius=mar, minor_radius=mir)
-            
-
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-                   
-
-        if not ob:
-            bpy.ops.mesh.primitive_torus_add(major_segments=mas, minor_segments=mis,major_radius=mar, minor_radius=mir)
-            ob = context.object
-            ob.name =  ob.data.name = "PovTorus"
-            ob.pov.object_as = "TORUS"
-            ob.pov.torus_major_segments = mas
-            ob.pov.torus_minor_segments = mis
-            ob.pov.torus_major_radius = mar
-            ob.pov.torus_minor_radius = mir
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-            
-class POVRAY_OT_torus_add(bpy.types.Operator):
-    bl_idname = "pov.addtorus"
-    bl_label = "Torus"
-    bl_description = "Add Torus"
-    bl_options = {'REGISTER', 'UNDO'}
-    
-    # XXX Keep it in sync with __init__'s torus Primitive
-    mas = IntProperty(name = "Major Segments",
-                    description = "",
-                    default = 48, min = 3, max = 720)
-    mis = IntProperty(name = "Minor Segments",
-                    description = "",
-                    default = 12, min = 3, max = 720)
-    mar = FloatProperty(name = "Major Radius",
-                    description = "",
-                    default = 1.0)
-    mir = FloatProperty(name = "Minor Radius",
-                    description = "",
-                    default = 0.25)
-    def execute(self,context):
-        props = self.properties
-        mar = props.mar
-        mir = props.mir
-        mas = props.mas
-        mis = props.mis
-        pov_torus_define(context, self, None)
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        return {'FINISHED'}
-
-
-class POVRAY_OT_torus_update(bpy.types.Operator):
-    bl_idname = "pov.torus_update"
-    bl_label = "Update"
-    bl_description = "Update Torus"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-
-        pov_torus_define(context, None, context.object)
-
-        return {'FINISHED'}        
-        
-###################################################################################
-
-
-class POVRAY_OT_prism_add(bpy.types.Operator):
-    bl_idname = "pov.addprism"
-    bl_label = "Prism"
-    bl_description = "Create Prism"
-    bl_options = {'REGISTER', 'UNDO'}
-    
-    prism_n = IntProperty(name = "Sides",
-                description = "Number of sides",
-                default = 5, min = 3, max = 720)
-    prism_r = FloatProperty(name = "Radius",
-                    description = "Radius",
-                    default = 1.0)
-    def execute(self,context):
-        
-        props = self.properties
-        loftData = bpy.data.curves.new('Prism', type='CURVE')
-        loftData.dimensions = '2D'
-        loftData.resolution_u = 2
-        loftData.show_normal_face = False
-        loftData.extrude = 2
-        n=props.prism_n
-        r=props.prism_r
-        coords = []
-        z = 0
-        angle = 0
-        for p in range(n):
-            x = r*cos(angle)
-            y = r*sin(angle)
-            coords.append((x,y,z))
-            angle+=pi*2/n
-        poly = loftData.splines.new('POLY')
-        poly.points.add(len(coords)-1)
-        for i, coord in enumerate(coords):
-            x,y,z = coord
-            poly.points[i].co = (x, y, z, 1)
-        poly.use_cyclic_u = True
-
-        ob = bpy.data.objects.new('Prism_shape', loftData)
-        scn = bpy.context.scene
-        scn.objects.link(ob)
-        scn.objects.active = ob
-        ob.select = True
-        ob.pov.curveshape = "prism"
-        ob.name = ob.data.name = "Prism"
-        return {'FINISHED'}
-        
-##############################PARAMETRIC######################################
-def pov_parametric_define(context, op, ob):      
-        if op:
-            u_min = op.u_min
-            u_max = op.u_max
-            v_min = op.v_min
-            v_max = op.v_max
-            x_eq = op.x_eq
-            y_eq = op.y_eq
-            z_eq = op.z_eq
-
-        else:
-            assert(ob)
-            u_min = ob.pov.u_min
-            u_max = ob.pov.u_max
-            v_min = ob.pov.v_min
-            v_max = ob.pov.v_max
-            x_eq = ob.pov.x_eq
-            y_eq = ob.pov.y_eq
-            z_eq = ob.pov.z_eq
-            
-            #keep object rotation and location for the updated object
-            obloc = ob.location
-            obrot = ob.rotation_euler # In radians
-            #Parametric addon has no loc rot, some extra work is needed
-            #in case cursor has moved
-            curloc = bpy.context.scene.cursor_location
-
-    
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.reveal()
-            bpy.ops.mesh.select_all(action='SELECT')
-            bpy.ops.mesh.delete(type='VERT')
-            bpy.ops.mesh.primitive_xyz_function_surface(x_eq=x_eq, y_eq=y_eq, z_eq=z_eq, range_u_min=u_min, range_u_max=u_max, range_v_min=v_min, range_v_max=v_max)
-            bpy.ops.mesh.select_all(action='SELECT')
-            #extra work:
-            bpy.ops.transform.translate(value=(obloc-curloc), proportional_size=1)
-            bpy.ops.transform.rotate(axis=obrot, proportional_size=1)
-            
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-
-
-        if not ob:
-            bpy.ops.mesh.primitive_xyz_function_surface(x_eq=x_eq, y_eq=y_eq, z_eq=z_eq, range_u_min=u_min, range_u_max=u_max, range_v_min=v_min, range_v_max=v_max)
-            ob = context.object
-            ob.name =  ob.data.name = "PovParametric"
-            ob.pov.object_as = "PARAMETRIC"
-            
-            ob.pov.u_min = u_min
-            ob.pov.u_max = u_max
-            ob.pov.v_min = v_min
-            ob.pov.v_max = v_max
-            ob.pov.x_eq = x_eq
-            ob.pov.y_eq = y_eq
-            ob.pov.z_eq = z_eq
-
-            bpy.ops.object.mode_set(mode="EDIT")
-            bpy.ops.mesh.hide(unselected=False)
-            bpy.ops.object.mode_set(mode="OBJECT")
-class POVRAY_OT_parametric_add(bpy.types.Operator):
-    bl_idname = "pov.addparametric"
-    bl_label = "Parametric"
-    bl_description = "Add Paramertic"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    # XXX Keep it in sync with __init__'s Parametric primitive
-    u_min = FloatProperty(name = "U Min",
-                    description = "",
-                    default = 0.0)
-    v_min = FloatProperty(name = "V Min",
-                    description = "",
-                    default = 0.0)
-    u_max = FloatProperty(name = "U Max",
-                    description = "",
-                    default = 6.28)
-    v_max = FloatProperty(name = "V Max",
-                    description = "",
-                    default = 12.57)
-    x_eq = StringProperty(
-                    maxlen=1024, default = "cos(v)*(1+cos(u))*sin(v/8)")
-    y_eq = StringProperty(
-                    maxlen=1024, default = "sin(u)*sin(v/8)+cos(v/8)*1.5")
-    z_eq = StringProperty(
-                    maxlen=1024, default = "sin(v)*(1+cos(u))*sin(v/8)")
-    
-    def execute(self,context):
-        props = self.properties
-        u_min = props.u_min
-        v_min = props.v_min
-        u_max = props.u_max
-        v_max = props.v_max
-        x_eq = props.x_eq
-        y_eq = props.y_eq
-        z_eq = props.z_eq
-        
-        pov_parametric_define(context, self, None)
-        self.report({'WARNING'}, "This native POV-Ray primitive "
-                                 "won't have any vertex to show in edit mode")
-        return {'FINISHED'}
-
-class POVRAY_OT_parametric_update(bpy.types.Operator):
-    bl_idname = "pov.parametric_update"
-    bl_label = "Update"
-    bl_description = "Update parametric object"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        engine = context.scene.render.engine
-        ob = context.object
-        return (ob and ob.data and ob.type == 'MESH' and engine in cls.COMPAT_ENGINES)
-
-    def execute(self, context):
-
-        pov_parametric_define(context, None, context.object)
-
-        return {'FINISHED'}
-#######################################################################
-class POVRAY_OT_shape_polygon_to_circle_add(bpy.types.Operator):
-    bl_idname = "pov.addpolygontocircle"
-    bl_label = "Polygon To Circle Blending"
-    bl_description = "Add Polygon To Circle Blending Surface"
-    bl_options = {'REGISTER', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-    
-    # XXX Keep it in sync with __init__'s polytocircle properties
-    polytocircle_resolution = IntProperty(name = "Resolution",
-                    description = "",
-                    default = 3, min = 0, max = 256)
-    polytocircle_ngon = IntProperty(name = "NGon",
-                    description = "",
-                    min = 3, max = 64,default = 5)
-    polytocircle_ngonR = FloatProperty(name = "NGon Radius",
-                    description = "",
-                    default = 0.3)
-    polytocircle_circleR = FloatProperty(name = "Circle Radius",
-                    description = "",
-                    default = 1.0)
-    def execute(self,context):
-        props = self.properties
-        ngon = props.polytocircle_ngon
-        ngonR = props.polytocircle_ngonR
-        circleR = props.polytocircle_circleR
-        resolution = props.polytocircle_resolution
-        layers = 20*[False]
-        layers[0] = True
-        bpy.ops.mesh.primitive_circle_add(vertices=ngon, radius=ngonR, fill_type='NGON',enter_editmode=True, layers=layers)
-        bpy.ops.transform.translate(value=(0, 0, 1))
-        bpy.ops.mesh.subdivide(number_cuts=resolution)
-        numCircleVerts = ngon + (ngon*resolution)
-        bpy.ops.mesh.select_all(action='DESELECT')
-        bpy.ops.mesh.primitive_circle_add(vertices=numCircleVerts, radius=circleR, fill_type='NGON',enter_editmode=True, layers=layers)
-        bpy.ops.transform.translate(value=(0, 0, -1))
-        bpy.ops.mesh.select_all(action='SELECT')
-        bpy.ops.mesh.bridge_edge_loops()
-        if ngon < 5:
-            bpy.ops.mesh.select_all(action='DESELECT')
-            bpy.ops.mesh.primitive_circle_add(vertices=ngon, radius=ngonR, fill_type='TRIFAN',enter_editmode=True, layers=layers)
-            bpy.ops.transform.translate(value=(0, 0, 1))
-            bpy.ops.mesh.select_all(action='SELECT')
-            bpy.ops.mesh.remove_doubles()
-        bpy.ops.object.mode_set(mode='OBJECT')
-        ob = context.object
-        ob.name = "Polygon_To_Circle"
-        ob.pov.object_as = 'POLYCIRCLE'
-        ob.pov.ngon = ngon
-        ob.pov.ngonR = ngonR
-        ob.pov.circleR = circleR
-        bpy.ops.object.mode_set(mode="EDIT")
-        bpy.ops.mesh.hide(unselected=False)
-        bpy.ops.object.mode_set(mode="OBJECT")
-        return {'FINISHED'}
-        
-#############################IMPORT
-class ImportAvogadroPOV(bpy.types.Operator, ImportHelper):
-    """Load Povray File as output by Avogadro"""
-    bl_idname = "import_scene.avogadro"
-    bl_label = "Import POV Avogadro"
-    bl_options = {'PRESET', 'UNDO'}
-    COMPAT_ENGINES = {'POVRAY_RENDER'}
-
-    filename_ext = ".pov"
-    filter_glob = StringProperty(
-            default="*.pov",
-            options={'HIDDEN'},
-            )
-
-    def execute(self, context):
-        coords=[]
-        colors = []
-        matNames = []
-        xall = yall = zall = []
-        layers = 20*[False]
-        layers[0] = True
-        ob = None
-        camloc = (0,0,0)
-        filepov = bpy.path.abspath(self.filepath)
-        for line in open(filepov):
-            string = line.replace("<"," ")
-            chars = [">","{","}",","]
-            for symbol in chars:
-                string = string.replace(symbol," ")
-            split = string.split()
-            if split and split[0] == "location":
-                x = float(split[1])
-                y = float(split[2])
-                z = float(split[3])
-                camloc = ((x,y,z))
-            if split and len(split) == 7:
-                try:
-                    x1 = float(split[0])
-                    coords.append(x1)
-                except:
-                    pass
-                if coords != []:            
-                    x1 = float(split[0])
-                    y1 = float(split[1])
-                    z1 = float(split[2])
-                    x2 = float(split[3])
-                    y2 = float(split[4])
-                    z2 = float(split[5])
-                    xall.append(x1)
-                    yall.append(y1)
-                    zall.append(z1)
-                    xall.append(x2)
-                    yall.append(y2)
-                    zall.append(z2)
-                    radius = float(split[6])
-                    curveData = bpy.data.curves.new('myCurve', type='CURVE')
-                    curveData.dimensions = '3D'
-                    curveData.resolution_u = 2
-                    curveData.fill_mode = "FULL"
-                    curveData.bevel_depth = radius
-                    curveData.bevel_resolution = 5
-                    polyline = curveData.splines.new('POLY')
-                    polyline.points.add(1) 
-                    polyline.points[0].co = (x1, y1, z1, 1)
-                    polyline.points[1].co = (x2, y2, z2, 1)
-                    ob = bpy.data.objects.new('myCurve', curveData)
-                    scn = bpy.context.scene
-                    scn.objects.link(ob)
-                    scn.objects.active = ob
-                    ob.select = True
-                    bpy.ops.object.convert(target='MESH',keep_original=False)
-                    #XXX TODO use a PovCylinder instead of mesh 
-                    #but add end points and radius to addPovcylinder op first
-                    ob.select=False
-                    coords = []
-            if split and len(split) == 4:
-                try:
-                    x = float(split[0])
-                    coords.append(x)
-                except:
-                    pass
-                if coords != []:
-                    x = float(split[0])
-                    y = float(split[1])
-                    z = float(split[2])
-                    xall.append(x)
-                    yall.append(y)
-                    zall.append(z)
-                    radius = float(split[3])
-                    
-
-                    ob.pov.imported_loc=(x, y, z)
-                    bpy.ops.pov.addsphere(R=radius, imported_loc=(x, y, z))
-                    bpy.ops.object.shade_smooth()
-                    ob = bpy.context.object
-                    coords = []        
-            if split and len(split) == 6:
-                if split[0] == "pigment":
-                    r,g,b,t = float(split[2]),float(split[3]),float(split[4]),float(split[5])
-                    color = (r,g,b,t)
-                    if colors == [] or (colors != [] and color not in colors):
-                        colors.append(color)
-                        name = ob.name+"_mat"
-                        matNames.append(name)
-                        mat = bpy.data.materials.new(name)
-                        mat.diffuse_color = (r,g,b)
-                        mat.alpha = 1-t
-                        ob.data.materials.append(mat)
-                        print (colors)
-                    else:
-                        for i in range(len(colors)):
-                            if color == colors[i]:
-                                ob.data.materials.append(bpy.data.materials[matNames[i]])
-        x0 = min(xall)
-        x1 = max(xall)
-        y0 = min(yall)
-        y1 = max(yall)
-        z0 = min(zall)
-        z1 = max(zall)
-        x = (x0+x1)/2
-        y = (y0+y1)/2
-        z = (z0+z1)/2
-        bpy.ops.object.empty_add(layers=layers)
-        ob = bpy.context.object
-        ob.location = ((x,y,z))
-        for obj in bpy.context.scene.objects:
-            if obj.type == "CAMERA":
-                track = obj.constraints.new(type = "TRACK_TO")
-                track.target = ob
-                track.track_axis ="TRACK_NEGATIVE_Z"
-                track.up_axis = "UP_Y"
-                obj.location = camloc
-        for obj in bpy.context.scene.objects:
-            if obj.type == "LAMP":
-                obj.location = camloc
-                obj.pov.light_type = "shadowless"
-                break
-        return {'FINISHED'}