How to pull specific information from an output in Python
Question: So I have a code that gives an output, and what I need to do is pull the
information out in between the commas, assign them to a variable that changes
dynamically when called... here is my code:

    
    
    import re
    
    data_directory = 'Z:/Blender_Roto/'
    data_file = 'diving_board.shape4ae'
    fullpath = data_directory + data_file
    
    
    print("====init=====")
    
    file = open(fullpath)
    for line in file:
    current_line = line
    
    # massive room for optimized code here.
    
    # this assumes the last element of the line containing the words
    # "Units Per Second" is the number we are looking for.
    # this is a non float number, generally.
    if current_line.find("Units Per Second") != -1:
        fps = line_split = float(current_line.split()[-1])
        print("Frames Per Second:", fps)
    
    # source dimensions
    if current_line.find("Source Width") != -1:
        source_width = line_split = int(current_line.split()[-1])
        print("Source Width:", source_width)
    
    if current_line.find("Source Height") != -1:
        source_height = line_split = int(current_line.split()[-1])
        print("Source Height:", source_height)
    
    # aspect ratios
    if current_line.find("Source Pixel Aspect Ratio") != -1:
        source_px_aspect = line_split = int(current_line.split()[-1])
        print("Source Pixel Aspect Ratio:", source_px_aspect)
    
    if current_line.find("Comp Pixel Aspect Ratio") != -1:
        comp_aspect = line_split = int(current_line.split()[-1])
        print("Comp Pixel Aspect Ratio:", comp_aspect)
    
    
    # assumption, ae file can contain multiple mocha shapes.
    # without knowing the exact format i will limit the script
    # to deal with one mocha shape being animated N frames.
    
    # this gathers the shape details, and frame number but does not
    # include error checking yet.
    if current_line.find("XSpline") != -1:
    
        # record the frame number.
    
        frame = re.search("\s*(\d*)\s*XSpline", current_line)
        if frame.group(1) != None:
            frame = frame.group(1)
            print("frame:", frame)
    
    
        # pick part the part of the line that deals with geometry
        match = re.search("XSpline\((.+)\)\n", current_line)
    
        line_to_strip = match.group(1)
        points = re.findall('(\(.*?\))', line_to_strip)
    
        print(len(points))
        for point in points:
            print(point)
        print("="*40)
    
    file.close()
    

This gives me the output:

    
    
    ====init=====
    Frames Per Second: 24.0
    Source Width: 2048
    Source Height: 778
    Source Pixel Aspect Ratio: 1
    Comp Pixel Aspect Ratio: 1
    frame: 20
    5
    (0.793803,0.136326,0,0.5,0)
    (0.772345,0.642332,0,0.5,0)
    (0.6436,0.597615,0,0.5,0)
    (0.70082,0.143387,0,0.5,0.25)
    (0.70082,0.112791,0,0.5,0)
    ========================================
    

So what I need for example is to be able to assign (0.793803, 0.136326, 0,
0.5, 0) to (1x,1y,1z,1w,1s), (0.772345,0.642332,0,0.5,0) to (2x, 2y, 2z, 2w,
2s) etc so that no matter what numbers are filling those positions they will
take on that value.

here is the code I need to put those numbers into:

    
    
    #-------------------------------------------------------------------------------
    # Name:        Mocha Rotoscoping Via Blender
    # Purpose:     Make rotoscoping more efficient
    #
    # Author:      Jeff Owens
    #
    # Created:     11/07/2011
    # Copyright:   (c) jeff.owens 2011
    # Licence:     Grasshorse
    #-------------------------------------------------------------------------------
    #!/usr/bin/env python
    
    import sys
    import os
    import parser
    sys.path.append('Z:\_protomotion\Prog\HelperScripts')
    import GetDir
    sys.path.append('Z:\_tutorials\01\tut01_001\prod\Blender_Test')
    filename = 'diving_board.shape4ae'
    infile = 'Z:\_tutorials\01\tut01_001\prod\Blender_Test'
    import bpy
    from mathutils import Vector
    
    #below are taken from mocha export
    x_width =2048
    y_height = 778
    z_depth = 0
    frame = 20
    
    def readText():
    text_file = open('diving_board.shape4ae', 'r')
    lines = text_file.readlines()
    print (lines)
    print (len.lines)
    for line in lines:
        print (line)
    
    ##sets points final x,y,z value taken from mocha export for blender interface
    
    point1x = (0.642706 * x_width)
    point1y = (0.597615 * y_height)
    point1z = (0 * z_depth) 
    
    point2x = (0.770557 * x_width)
    point2y = (0.647039 * y_height)
    point2z = (0 * z_depth)
    
    point3x = (0.794697 * x_width)
    point3y = (0.0869024 * y_height)
    point3z = (0 * z_depth)
    
    
    point4x = (0.707973* x_width)
    point4y = (0.0751348 * y_height)
    point4z = (0 * z_depth)
    
    
    w = 1 # weight
    listOfVectors = [Vector((point1x,point1y,point1z)),Vector((point2x,point2y,point2z)),Vector((point3x,point3    y,point3z)),Vector((point4x,point4y,point4z)), Vector((point1x,point1y,point1z))]
    
    def MakePolyLine(objname, curvename, cList):
    curvedata = bpy.data.curves.new(name=curvename, type='CURVE')
    curvedata.dimensions = '3D'
    
    objectdata = bpy.data.objects.new(objname, curvedata)
    objectdata.location = (0,0,0) #object origin
    bpy.context.scene.objects.link(objectdata)
    
    polyline = curvedata.splines.new('POLY')
    polyline.points.add(len(cList)-1)
    for num in range(len(cList)):
        x, y, z = cList[num]
        polyline.points[num].co = (x, y, z, w)
    
    MakePolyLine("NameOfMyCurveObject", "NameOfMyCurve", listOfVectors)
    

So where I have my vector I would like to be able to place (p.x,
p.y,0.z,p.w,p.s) then (p2.x,p2.y,p2.zp2.wp2.s) etc so that it can change per
the number given

Any help will be great.. thank you in advance!

-jeff


Answer: Instead of _printing_ each output, you can create point objects and index them
by name. For example:

    
    
    >>> class Point:
    ...     def __init__(self, t):
    ...         (self.x,self.y,self.z,self.w,self.s) = t
    ... 
    >>> p = Point( (3,4,5,3,1) )
    >>> p.w
    3
    

You can place these point objects in an array, then access components by

    
    
    myPoints[3].x
    

**ADDENDUM**

If it is important to you _not_ to pull the points from an array, but rather
use actual variable names, you _can_ do the following, where `points` is your
**array of tuples** :

    
    
    (p0x,p0y,p0z,p0w,p0s) = points[0]
    (p1x,p1y,p1z,p1w,p1s) = points[1]
    (p2x,p2y,p2z,p2w,p2s) = points[2]
    ...
    

and so on.

Do consider whether this is an appropriate approach though. Having a point
class allows you to have any number of points. With defined variable names,
creating an unbounded number of these things on the fly is possible but almost
always a bad idea. Here is a caveat about doing so:
<http://mail.python.org/pipermail/tutor/2005-January/035232.html>.

When you have an array of point objects you do what you want much better! For
example you can do the following:

    
    
    myPoints[i].y = 12
    

thereby changing the y-coordinate of the ith point. This is next to impossible
when you have fixed the variable names. Hope that helps! (And hope I
understand your clarification! Let me know if not....)

