separated pov native primitives to this other python file with operators for import and export.

1 files changed, 1494 insertions, 0 deletions

diff --git a/render_povray/primitives.py b/render_povray/primitives.py
new file mode 100644
index 00000000..c668ed26
--- /dev/null
+++ b/render_povray/primitives.py
@@ -0,0 +1,1494 @@
+############ To get POV-Ray specific objects In and Out of Blender ###########
+
+import bpy
+#from . import render
+#from render import POVRAY_RENDER
+from bpy_extras.io_utils import ImportHelper
+from bpy_extras import object_utils
+from math import atan, pi, degrees, sqrt, cos, sin
+
+
+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'}