Blender/Python: Plot stars from the HYG data (version 2015-03-05)

slightly updated version from what was previously posted....

the colours for the spectral types are over-saturated but what I do to correct this is put the stars into their own layer in Blender and from there I use the compositing node that reduces the saturation of the colours down to the point where the colours look realistic.

In the compositing screen below I have FOUR layers, FUZZIER and FUZZY are used for blurring the atmosphere, auroras or whatever needs to be blurred. Generally I have two fuzzy layers because I often find that I need to have two independent levels of configurable fuzziness so I just make the two layers for using blurring and glare nodes of some kind so that I don't have to add them later. the PLANET layer is the main layer where the planets and moons and such are placed and the STARS layer is for the background stars

I reduce the saturation of the background stars so as to reduce the "colourness" of the background stars as this script makes the colours rather vibrant. ie. M class stars are bright red (R,G,B = 1,0,0) which isn't a very realistic colour for M class stars. I also add a bit of glare to the background stars such that there aren't solid points of light.

The script below only supports plotting stars on the inside of a sphere, I haven't quite got the relative brightness of stars correct when plotting a star field in which you could move the camera around and see the perspective and relative stellar positions change. eg. If you moved the camera to Alpha Centauri, you would see that the star Sirius is now a part of the Orion constellation and our Sun would become a star in Cassiopeia.

#!/usr/local/bin/python
#
# $Header: /home/zero/Blender/Starfield-Solid-Halo/RCS/starfield-solid-halo-019.py,v 1.3 2015/03/21 22:29:44 zero Exp zero $
#
# PURPOSE:
#
# Script to build up a starfield using the data from the HYG catalogue
#
# DATA SOURCE:
#
# http://astronexus.com/node/34
#
# GET data file from http://astronexus.com/files/downloads/hygxyz.csv.gz
#
# DESCRIPTION:
#
# Stars are plotted on the "inside" of an imaginary sphere. Most stars
# are plotted as tetrahedrons, brighter stars as octahedrons and brightest
# stars as dodecahedrons. Stars are plotted according to their spectral type
# with each spectral type being a seperate object
#
# USAGE:
#
# I run this on my FreeBSD machine with 
#
# unix:~ $ blender -noaudio -P starsphere-sol-solid.py >& OUT < /dev/null &
#
# then once it has finished, (it can take many hours to run) I save the whole
# thing as a .blend file and then I *append* it into Blender via the
# "Shift-F1" feature (Menu: File->Append)
#
# I see no reason why this wouldn't run on other Unix variants, but if you are 
# going to use this on Windows then I've got no idea if it will work for you!
#
# NOTE that blender seems to take quite a while to exit after generating
# the field, but once the .blend file is saved and loaded again, blender runs
# like it normally does
import os  
import sys
from mathutils import *; from math import *
import re
import bpy
import traceback

#----------------------------------------------------------------------------
#
# Alter this to point to where you have put your downloaded copy of the Gzipped data
#
hygxyz_file = '/home/zero/Downloads/hygxyz.csv.gz'

#
# full path name of the appropriate unzipper to decompress the data file
#
dezipper = '/usr/bin/gzcat'

#----------------------------------------------------------------------------
# turn on debugging output
debug = 1

# anything fainter than this is skipped completely 
# this is used in the main loop and has no effect on the star size
# NOTE: any value above 20 will give you to *whole* 120,000+ stars
# from the HYG catalog and will take something like six hours to run.
# for testing it out, set the value to 5.0 or so and that will only plot
# the brightest stars
# skip_mag = 5.0 # Takes about twenty seconds
# skip_mag = 6.0 # Takes about ten minutes
# skip_mag = 8.0 # Takes about thirty-five minutes
skip_mag = 5.0

# "base" minimum star brightness, this is used for size of star calculations.
# set to 20 to as brown dwarf stars tend to be this bright (absolute magnitude)
faintest = 20

# Plot all stars in a sphere so all stars are the same distance away
# from the camera, requires use of Visual magnitude - if this isn't set
# stars will be plotted in a star field using X Y Z co-ordinates
# SET THIS TO 1 TO PLOT STARS ON THE INSIDE OF A SPHERE
use_starsphere = 1

# Plot the Bayerflamsteed names
use_bayerflamsteed = 0

# Stars will be plotted on the inside "surface" of an imaginary sphere
# with a radius this big - used when 'use_starsphere' is set to '1'
sphere_size = 3000

# Set this to "1" to warp the location of stars in the direction of the warp value distance
# "warp" makes close stars further away and far stars closer - the purpose of which is bunch
# the stars closer together in the star field rather than have them plotted too far away.
# can only used when use_starsphere is set to '0'
# SET THIS TO 1 TO PLOT STARS IN A STARFIELD
# NOTE THAT THIS FEATURE IS NOT WORKING PROPERLY YET
use_warp = 0

# Set this to "1" to only warp stars that are further away than the warp value distance
# set to "1" if you plan to move the camera around the local area, ie retain local perspective
# NOTE THAT THIS FEATURE IS NOT WORKING PROPERLY YET
use_far_warp_only = 0

# this distance threshold for this "warp" thing
warp_value = 1000

# reduce or scale up the size of the plotted grid - this determines how big the
# overall size of the grid is scaled.. values above one make the scale smaller
# and decimal values between 0 and 1 make it larger - 1 has no effect and 0
# should be avoided and negatives, well you're on your own with that one :)
global_scaler = 0.1


# Offsets - set this offset to make another star the centre of the 3d area
# Alcyone bf=25Eta Tau abs=-2.410 spec=B7III x=56.24191 y=86.17987 z=46.04441
#offset_x = 56.24191
#offset_y = 86.17987
#offset_z = 46.04441
#offset_x = -0.47175
#offset_y = -0.36132
#offset_z = -1.15037
offset_x = 0
offset_y = 0
offset_z = 0

# Normal Sol
# 0,,,,,,Sol,0,0,0.000004848,0,0,0,-26.73,4.85,G2V,0.656,0,0,0,0,0,0
# Sol from Proxima
# 0,,,,,,Sol,0,0,0.000004848,0,0,0,0.4,4.85,G2V,0.656,0,0,0,0,0,0


# restrict the size of the cube in which we plot eg. restricting xyz to plus or
# minus 100, would see a max cube size of 200x200x200 -- this doesn't mean
# all the stars are plotted in a grid of this size, it means that they are
# skipped completely if any of their co-ordinates exceed this value
max_xyz = 8000

#----------------------------------------------------------------------------
# solid calculations are based on bits of code from blender itself. 
# under FreeBSD the file is located here...
# /usr/local/share/blender/scripts/addons/add_mesh_extra_objects/add_mesh_solid.py
def calculate_tetrahedron(factor):
    s = (sqrt(2)/3.0) * factor
    t = (-1/3) * factor
    u = (sqrt(6)/3) * factor
    v = 1 * factor
    verts = [(0,0,v),(2*s,0,t),(-s,u,t),(-s,-u,t)]
    faces = [[0,1,2],[0,2,3],[0,3,1],[1,3,2]]
    return verts, faces

#----------------------------------------------------------------------------
def calculate_octahedron(factor):
    v = 1 * factor
    verts = [(v,0,0),(-v,0,0),(0,v,0),(0,-v,0),(0,0,v),(0,0,-v)]
    faces = [[4,0,2],[4,2,1],[4,1,3],[4,3,0],[5,2,0],[5,1,2],[5,3,1],[5,0,3]]
    return verts, faces

#----------------------------------------------------------------------------
def calculate_dodecahedron(factor):
    s = 1/sqrt(3) * factor
    t = sqrt((3-sqrt(5))/6) * factor
    u = sqrt((3+sqrt(5))/6) * factor
    verts = [(s,s,s),(s,s,-s),(s,-s,s),(s,-s,-s),(-s,s,s),(-s,s,-s),(-s,-s,s),(-s,-s,-s),
         (t,u,0),(-t,u,0),(t,-u,0),(-t,-u,0),(u,0,t),(u,0,-t),(-u,0,t),(-u,0,-t),(0,t,u),
         (0,-t,u),(0,t,-u),(0,-t,-u)]
    faces = [[0,8,9,4,16],[0,12,13,1,8],[0,16,17,2,12],[8,1,18,5,9],[12,2,10,3,13],
             [16,4,14,6,17],[9,5,15,14,4],[6,11,10,2,17],[3,19,18,1,13],[7,15,5,18,19],
             [7,11,6,14,15],[7,19,3,10,11]]
    return verts, faces

#----------------------------------------------------------------------------
# get halo size
def get_halo_size(mag):

    #magList = [
    #    0.01250, 0.02407, 0.03747, 0.05298, 0.07093, 0.09171, 0.11575, 0.14359,
    #    0.17581, 0.21310, 0.25627, 0.30623, 0.36406, 0.43100, 0.50848, 0.59816,
    #    0.70197, 0.82212, 0.96119, 1.12217, 1.30849, 1.52416, 1.77379, 2.06274,
    #    2.39718, 2.78430, 3.23238, 3.75102, 4.35134, 5.04619, 5.85047
    #];

    magList = [
        0.1022, 0.1031, 0.1044, 0.1063, 0.1088, 0.1125, 0.1177, 0.1250,
        0.1354, 0.1500, 0.1707, 0.1999, 0.2413, 0.2998, 0.3825, 0.4995,
        0.6649, 0.8988, 1.2295, 1.6971, 2.3583, 3.2933, 4.6153, 6.4846,
        9.1278, 12.8653, 18.1502, 25.6229, 36.1894, 51.1304, 72.2570
    ];

    #magList = [
    #    0.0022, 0.0031, 0.0044, 0.0063, 0.0089, 0.0125, 0.0177, 0.0250,
    #    0.0354, 0.0501, 0.0708, 0.1001, 0.1415, 0.2001, 0.2829, 0.4001,
    #    0.5657, 0.7999, 1.1311, 1.5993, 2.2614, 3.1977, 4.5215, 6.3934,
    #    9.0403, 12.7830, 18.0752, 25.5583, 36.1394, 51.1011, 72.2570
    #];


    # adjust for 3 Puppis (the absolute mag brightest star) it will be factor=0
    magindex = int(len(magList) - (mag + 11.06))
    if debug > 6: print('len(magList)={} - mag={} + 11.06 == magindex={}'.format(
        len(magList), mag, magindex))

    return (magindex, magList[magindex])

#----------------------------------------------------------------------------
# given a spectral type, return an approximation of its colour in (R, G, B)
def get_star_colour(spectral_type):

    # Extract the spectral Letter and Number
    m = spectral_type_regex.match(spectral_type)

    # spectral Letter
    s_l = m.group(1)
    # spectral Number
    s_n = m.group(2)

    if debug > 5: print('s_l={} s_n={}'.format(s_l, s_n))

    # bit of a dogdy algorithm to set the colour but it's good enough for now
    if   m_regex.search(s_l): colour = (1.00, 0.00 + (int(s_n)/20.0), 0.00)
    elif k_regex.search(s_l): colour = (1.00, 0.50 + (int(s_n)/20.0), 0.00)
    elif g_regex.search(s_l): colour = (1.00, 1.00, 0.00 + (int(s_n)/20.0))
    elif f_regex.search(s_l): colour = (1.00, 1.00, 0.50 + (int(s_n)/20.0))
    elif a_regex.search(s_l): colour = (1.00 - (int(s_n)/40.0), 1.00 - (int(s_n)/40.0), 1.00)
    elif b_regex.search(s_l): colour = (0.75 - (int(s_n)/40.0), 0.75 - (int(s_n)/40.0), 1.00)
    elif o_regex.search(s_l): colour = (0.50 - (int(s_n)/80.0), 0.50 - (int(s_n)/80.0), 1.00)
    else: colour = ( 1.00, 1.00, 1.00 )

    return colour

#----------------------------------------------------------------------------
# create solid using given magnitude
def create_star_solid(mesh,mag):

    magList = [
        0.0125, 0.0250, 0.0500, 0.0750, 0.1000, 0.2000, 0.3000, 0.4000, 0.5000, 0.6000,
        0.7000, 0.8000, 0.9000, 1.5000, 2.2000, 3.0000, 3.9000, 4.9000, 6.0000, 6.4000,
        6.8000, 7.2000
    ];
    # adjust for Sirius (the brightest star) it will be factor=0
    magfactor = int((faintest - mag + 1.44)*0.85)
    #magfactor = int((len(magList) - mag + 1.44))
    if debug > 1: print('mag={} magfactor={}'.format(mag, magfactor))
    factor = magList[magfactor];
    # most stars will be a tetrahedron
    if   mag > 6: verts, faces = calculate_tetrahedron(factor)
    # brighter stars will be a octahedron
    elif mag > 3: verts, faces = calculate_octahedron(factor)
    # brightest stars will be a dodecahedron
    else:         verts, faces = calculate_dodecahedron(factor)

    #if magfactor > faintest: magfactor = faintest
    mesh.from_pydata(verts, [], faces)
    mesh.update()
    return


#----------------------------------------------------------------------------
# extract the first thing that looks like a spectral type,
# ie. for stars that have multiple spectral types listed, the first is used
def get_spectral_type(spectrum):
    m = spectrum_regex.match(spectrum)
    if m:
        spectral_type = m.group(1)
    else:
        if   m_regex.search(spectrum): spectral_type = 'M0'
        elif k_regex.search(spectrum): spectral_type = 'K0'
        elif g_regex.search(spectrum): spectral_type = 'G0'
        elif f_regex.search(spectrum): spectral_type = 'F0'
        elif a_regex.search(spectrum): spectral_type = 'A0'
        elif b_regex.search(spectrum): spectral_type = 'B0'
        elif o_regex.search(spectrum): spectral_type = 'O0'
        else:
            if debug > 1: print('unhandled spectral type "{}"'.format(spectrum))
            # if we can't make sense of the spectral type we are given, then
            # set the colour to be white instead of discarding it as unclassified
            spectral_type = 'A0'
    return spectral_type


#----------------------------------------------------------------------------
# create object under a parent
def create_star_object(spectral_type,mag,lx,ly,lz,RA,DEC):

    # create a mesh for this star
    star_mesh = bpy.data.meshes.new(spectral_type+'Mesh')

    # now create a new object for that mesh
    star_object = bpy.data.objects.new(spectral_type, star_mesh)

    # assign the parent
    star_object.parent = starfield_parent

    # set location
    star_object.location = (lx, ly, lz)

    # link object to the scene
    bpy.context.scene.objects.link(star_object)

    # Create a solid and use visual magnitude if we are creating a starsphere
    if use_starsphere > 0:
        create_star_solid(star_mesh, mag)
        # point the Z axis at origin - this is done so that the tetrahedron
        # has the maximum area pointing at the origin so that the surface
        # area is the same no matter where the star was plotted. If this wasn't
        # done, half of the tetrahedron stars would be "side-on" and would appear
        # slightly dimmer than they should be
        # star_object.matrix_world *= Matrix.Rotation(radians(RA*15), 4, "Z")
        # star_object.matrix_world *= Matrix.Rotation(radians((DEC+90)*-1), 4, "Y")

        # Get the material
        spectral_type_material = bpy.data.materials.get(spectral_type)

    # use halos and use absolute magnitude if we are creating a starfield
    else:
        # Add the star point
        star_object.data.vertices.add(1)

        magindex, magfactor = get_halo_size(mag)

        spectral_type_mag = "%s-MAG%03d" % (spectral_type, magindex)

        # Get the material
        spectral_type_material = bpy.data.materials.get(spectral_type_mag)

    # If the material is None, then we make an object material
    if spectral_type_material is None:
        if use_starsphere > 0:
            spectral_type_material = bpy.data.materials.new(spectral_type)
        else:
            spectral_type_material = bpy.data.materials.new(spectral_type_mag)

        star_object.data.materials.append(spectral_type_material)

        # get the colour 
        spectral_type_material.diffuse_color = get_star_colour(spectral_type)

        # specular colour isn't used but set it anyway
        spectral_type_material.specular_color = spectral_type_material.diffuse_color

        # turn on emit
        spectral_type_material.emit = 1

        # set various material properties that we aren't really interested
        # in ie. we don't have a specular for a point of light and we also
        # don't want these stars to be casting shadows, nor receiving them
        spectral_type_material.specular_intensity = 0
        spectral_type_material.ambient = 0
        spectral_type_material.use_shadows = 0
        #not sure about this one#spectral_type_material.use_raytrace = 0
        spectral_type_material.use_ray_shadow_bias = 0
        spectral_type_material.use_mist = 0
        spectral_type_material.use_cast_approximate = 0
        spectral_type_material.use_cast_buffer_shadows = 0

        # Set HALO material
        if use_starsphere == 0:
            spectral_type_material.type = 'HALO'
            spectral_type_material.halo.seed = 14
            spectral_type_material.halo.use_shaded = 0
            #obj.data.materials[0].halo.use_shaded=0
            spectral_type_material.halo.hardness = 127

            # set the material halo size
            spectral_type_material.halo.size = magfactor

            # turn on emit, not sure if that does anything with a halo anyway
            spectral_type_material.emit = 2

            # specular colour is also the colour of the lines for a halo
            # so we just set it at the diffuse value for the time being
            # ideally it should be set at half way between the diffuse colour
            # and white... 
            # spectral_type_material.specular_color = diffuse
            if mag < 0:
                spectral_type_material.halo.use_lines = 1
                spectral_type_material.halo.line_count = abs(round(mag)) * 2
            else:
                spectral_type_material.halo.use_lines = 0
                spectral_type_material.halo.line_count = 0

    else:
        star_object.data.materials.append(spectral_type_material)

    # If this is a subsequent star in a spectral type, join it to the first.
    # All master star objects will be two characters long G0 B6 K4 etc etc
    # Subsequent star objects will be A0.001 B6.001 etc etc so only the first
    # star created in a spectral type will have a two character name so all
    # subsequent ones will have a 6 character name
    if len(star_object.name) == 6:
        # deselect all
        bpy.ops.object.select_all(action='DESELECT')

        # Select the current star
        star_object.select = True

        # Select the master star object
        bpy.data.objects[spectral_type].select = True

        # Make the master star the active object
        bpy.context.scene.objects.active = bpy.data.objects[spectral_type]

        # now join them
        bpy.ops.object.join()
    return


#-------------------------------------------------------------------
# calculate X Y Z co-ordinates on the inside "surface" of a sphere
# algorithm from http://www.projectrho.com/public_html/starmaps/trigonometry.php
def plot_starsphere(spectral_type, mag, RA, DEC):
    PHI = radians(RA * 15)
    THETA = radians(DEC)
    RHO = sphere_size

    RVECT = RHO * cos(THETA)
    lx = RVECT * cos(PHI)
    ly = RVECT * sin(PHI)
    lz = RHO * sin(THETA)

    # Adjust for offset
    lx = lx - offset_x
    ly = ly - offset_y
    lz = lz - offset_z

    if debug > 2:
        print('plot_starsphere: RHO={} THETA={} PHI={} Mag={} Spectrum={} RA={} DEC={} lx={} ly={} lz={}'.format(
            RHO, THETA, PHI, mag, spectrum, RA, DEC, lx, ly, lz))

    # Add the star solid
    create_star_object(spectral_type, mag, lx, ly, lz, RA, DEC)
    return (lx, ly, lz)

#-------------------------------------------------------------------
def plot_starfield(spectral_type, absmag, RA, DEC, lx, ly, lz):
    if (-max_xyz<=lx<=max_xyz) and (-max_xyz<=ly<max_xyz) and (-max_xyz<=lz<max_xyz):
        # Add the star solid
        create_star_object(spectral_type, absmag, lx, ly, lz, RA, DEC)
    return

#-------------------------------------------------------------------
def create_starname_object(newtext, lx, ly, lz):
  
    if debug > 2: print('create_starname_object: lx={} ly={} lz={}'.format(lx, ly, lz))
    bpy.ops.object.text_add(view_align=False, enter_editmode=False, location=(lx, ly, lz))
    starname = bpy.context.object
    starname.data.body = newtext
    starname.name = newtext
    starname.parent = starname_parent
    if use_starsphere > 0:
        starname.data.size = 10
        starname.data.text_boxes[0].width = 2
        starname.data.text_boxes[0].height = 2
        starname.data.text_boxes[0].x = 2
        starname.data.text_boxes[0].y = 1
    else:
        starname.data.size = 0.5
        starname.data.text_boxes[0].width = 1.5
        starname.data.align = 'CENTER'

    bpy.ops.object.constraint_add(type='COPY_ROTATION')
    starname.constraints['Copy Rotation'].target = bpy.data.objects['STAR-CAM']
  
    # assign the starname material to the object
    starname.data.materials.append(starname_material)
    return

#-------------------------------------------------------------------------------
def process_line(propername,bayerflamsteed,RA,DEC,mag,absmag,spectral_type,lx,ly,lz):
    # Plot stars in a sphere 
    if use_starsphere > 0:
        px,py,pz = plot_starsphere(spectral_type, mag, RA, DEC)
    # or plot the stars as a field
    else:
        px = ( lx - offset_x )
        py = ( ly - offset_y )
        pz = ( lz - offset_z )
        if use_warp > 0:
            distance = ( sqrt((abs(px)**2) + (abs(py)**2) + (abs(pz)**2) ))
            # stars closer than the warp distance threshold 
            if ( use_far_warp_only == 0 ) and ( distance < warp_value ):
                difference = warp_value - distance

                # the new distance will be further away
                new_distance = distance + ( difference / 128 )

                # this should result in a value above 1
                if distance > 0: warp_factor = new_distance / distance
                else: warp_factor = 1
                px = px * warp_factor
                py = py * warp_factor
                pz = pz * warp_factor
            # stars more distant than the warp distance threshold 
            elif ( distance > warp_value ):
                difference = distance - warp_value
                # the new distance will be closer
                # new_distance = distance - ( difference / 1.1 )
                new_distance = distance - ( difference / 1.01 )

                # this should result in a value between 0 and 1
                warp_factor = new_distance / distance
                px = px * warp_factor
                py = py * warp_factor
                pz = pz * warp_factor
            if debug > 1:
                print('process_line: warp_factor={} warp_value={} distance={} x={:.3} y={:.3} z={:.3}'.format(
                       warp_factor, warp_value, distance, px, py, pz))

        px = ( px / global_scaler )
        py = ( py / global_scaler )
        pz = ( pz / global_scaler )
        plot_starfield(spectral_type, absmag, RA, DEC, px, py, pz)

    # Bayer-Flamsteed?
    if use_bayerflamsteed > 0 and bayerflamsteed != '':
        bayerflamsteed = white_space_rex.sub(' ', bayerflamsteed)
        if debug > 1: print('bayerflamsteed={}'.format(bayerflamsteed))
        create_starname_object(bayerflamsteed, px, py, pz)
    return

#-------------------------------------------------------------------------------
#---------------main------------------------------------------------------------
#-------------------------------------------------------------------------------
#
# Compile up the regexes (avoids compiling the regexes for each star plotted)
#
m_regex = re.compile('^[mM]')
k_regex = re.compile('^[kK]')
g_regex = re.compile('^[gG]')
f_regex = re.compile('^[fF]')
a_regex = re.compile('^[aA]')
b_regex = re.compile('^[bB]')
o_regex = re.compile('^[oO]')
spectrum_regex = re.compile("([OBAFGKM]\d)")
spectral_type_regex = re.compile("([OBAFGKM])(\d)")
white_space_rex = re.compile('\s+')

# Delete the default objects
# deselect all
bpy.ops.object.select_all(action='DESELECT')
# select all the default objects
bpy.data.objects['Cube'].select = True
bpy.data.objects['Lamp'].select = True
bpy.data.objects['Camera'].select = True
# and delete them
bpy.ops.object.delete()
# now remove the meshes, they have no users anymore.
for item in bpy.data.meshes: bpy.data.meshes.remove(item)

# Make sky completely black
bpy.data.worlds['World'].horizon_color = ( 0, 0, 0 )

#-------------------------------------------------------------------------------
# Add our own camera
bpy.ops.object.camera_add(view_align=False, location=(0, 0, 0), rotation=(radians(78), 0, 0))
# get the camera object
starcam = bpy.context.object
# set the camera object name
starcam.name = "STAR-CAM"
# set the camera clip to be far, far away
bpy.data.cameras[-1].clip_end=9999
# set the size of the camera to be really wide
bpy.data.cameras[-1].lens=22

#-------------------------------------------------------------------------------
# Add the Star objects' parent
bpy.ops.object.add(type='EMPTY')
# set object mode
bpy.ops.object.mode_set(mode='OBJECT')
# get object
starfield_parent = bpy.context.object
# set object name
starfield_parent.name = "STAR-SPHERE"

#------------------------------------------------------------------------------
if use_bayerflamsteed > 0:
    # Create an object for the text objects to point at
    bpy.ops.object.add(type='EMPTY')
    # set object mode
    bpy.ops.object.mode_set(mode='OBJECT')
    # get object
    text_tracker = bpy.context.object
    # set object name
    text_tracker.name = "TEXT-TRACKER"
    # Make the STAR-CAM the parent
    text_tracker.parent = bpy.data.objects['STAR-CAM']

    #---------------------------------------------------------------------------
    # add a parent for the star names
    bpy.ops.object.add(type='EMPTY')
    # get object
    starname_parent = bpy.context.object
    # set object name
    starname_parent.name = "STAR-NAMES"

    #---------------------------------------------------------------------------
    # create a mew material for star names
    starname_material = bpy.data.materials.new('STAR-NAMES')
    # set the colour for the star names material as yellow
    starname_material.diffuse_color = ( 0.8, 0.8, 0.0 )
    # turn on emit
    starname_material.emit = 1



#-MAIN-LOOP---------------------------------------------------------------------
# StarID,HIP,HD,HR,Gliese,BayerFlamsteed,ProperName,RA,DEC,Distance,PMRA,PMDEC,RV,Mag,AbsMag,Spectrum,ColorIndex,X,Y,Z,VX,VY,VZ
# read data file
for myline in os.popen(dezipper + ' ' + hygxyz_file):
    if debug > 8: sys.stdout.write(myline)

    # split the line into an array 'f' on the ',' field seperator
    f = myline.split(',')

    # apparently this is how you do things in python
    # this will attempt to parse the line
    # if for some reason it fails, it goes down to the bottom
    try:
        propername = str(f[6])
        # Skip the title record
        if propername == 'ProperName': continue
        # Skip the sun, it's supposed to be in the middle anyway
        if propername == 'Sol' and offset_x == 0 and offset_y == 0 and offset_z == 0: continue
        bayerflamsteed = str(f[5])
        RA = float(f[7])
        DEC = float(f[8])
        mag = float(f[13])
        absmag = float(f[14])

        # skip out if the star isn't very bright (for debugging)
        if use_starsphere > 0:
            if mag > skip_mag: continue
        else:
            if absmag > skip_mag: continue
        spectrum = f[15]

        spectral_type = get_spectral_type(spectrum)

        # skip out if we don't have a type - shouldn't happen, probably dud data
        if spectral_type == '': continue

        gx = float(f[17])
        gy = float(f[18])
        gz = float(f[19])
        process_line(propername,bayerflamsteed,RA,DEC,mag,absmag,spectral_type,gx,gy,gz)

        pass

    # this is called when the line is a dud
    except:
        print("something failed: input line was ", myline)
        if debug > 1:
            print('Star rejected ProperName={} Mag={} AbsMag={} Spectrum={} gx={} gy={} gz={}'.format(
                    propername, mag, absmag, spectrum, gx, gy, gz))
        traceback.print_exc()
        # Print some debugging info upon uncontrolled exit
        for i in bpy.data.meshes: print("MeshName=="+i.name)
        # exit completely if the debug setting is high
        if debug > 5: sys.exit()
        else: continue

# set object mode again
bpy.ops.object.mode_set(mode='OBJECT')


bpy.data.screens['Default'].areas[4].spaces[0].clip_end = 9999
bpy.data.screens['Default'].areas[4].spaces[0].show_relationship_lines = False

bpy.context.scene.render.resolution_percentage = 100