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

Perl/Math::Bezier ... plotting a bezier curve given some control points

doesn't actually draw anything - just gets the data points necessary to plot one. I did this because I needed a series of 22 numbers starting with 0.0125 that gradually ramped up to 7.4 with step getting larger for each iteration.

#!/usr/local/bin/perl -w

use strict;
use Math::Bezier;

my $MAXX = 22.0;
my $MAXY = 7.4;

my $x0 = 0;
my $y0 = 0.0125;
my $x1 = $MAXX*0.5;
my $y1 = 0.0000;
my $x2 = $MAXX;
my $y2 = $MAXY;

my @control = ( $x0, $y0, $x1, $y1, $x2, $y2 );


my $bezier = Math::Bezier->new(@control);

for ( my $i = 0; $i < ($MAXX+1); $i++) {

    my $divisor = $i / $MAXX;
    my ( $x, $y )  = $bezier->point($divisor);
    printf "divisor=%8.4f x=%8.4f y=%8.4f\n", $divisor, $x, $y;

}



unix:~ 1607 $ ./bezier.pl 
divisor=  0.0000 x=  0.0000 y=  0.0125
divisor=  0.0455 x=  1.0000 y=  0.0267
divisor=  0.0909 x=  2.0000 y=  0.0715
divisor=  0.1364 x=  3.0000 y=  0.1469
divisor=  0.1818 x=  4.0000 y=  0.2530
divisor=  0.2273 x=  5.0000 y=  0.3897
divisor=  0.2727 x=  6.0000 y=  0.5570
divisor=  0.3182 x=  7.0000 y=  0.7550
divisor=  0.3636 x=  8.0000 y=  0.9836
divisor=  0.4091 x=  9.0000 y=  1.2428
divisor=  0.4545 x= 10.0000 y=  1.5326
divisor=  0.5000 x= 11.0000 y=  1.8531
divisor=  0.5455 x= 12.0000 y=  2.2042
divisor=  0.5909 x= 13.0000 y=  2.5860
divisor=  0.6364 x= 14.0000 y=  2.9983
divisor=  0.6818 x= 15.0000 y=  3.4413
divisor=  0.7273 x= 16.0000 y=  3.9150
divisor=  0.7727 x= 17.0000 y=  4.4192
divisor=  0.8182 x= 18.0000 y=  4.9541
divisor=  0.8636 x= 19.0000 y=  5.5197
divisor=  0.9091 x= 20.0000 y=  6.1158
divisor=  0.9545 x= 21.0000 y=  6.7426
divisor=  1.0000 x= 22.0000 y=  7.4000

Perl get SSL certificate subject alternative names (aka aliases)

#!/usr/local/bin/perl -w

use strict;

my $website = $ARGV[0] || '';

die "usage: $0 <website:sslport>\n" if (($website eq '') || ($website !~ m!^\S+:\d+$!o));

my $openssl = '/usr/local/bin/openssl';

die "openssl binary not found at $openssl\n" if ( ! -x $openssl );

my $s_client_output = qx{ echo | $openssl s_client -connect $website 2> /dev/null };

my $certcount = 0;

while ($s_client_output =~ m!(-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----).*?!smg) {
    my $cert_text = $1;
    my $x509_out = qx{ echo '$cert_text' | $openssl x509 -noout -text 2> /dev/null };
    while ($x509_out =~ m!DNS:([\w\-\.\*]+).*?!smg) {
        my $alias = $1;
        printf "alias for %s (%d) == %s\n", $website, $certcount, $alias;
    }
    $certcount++;
}

Blender/Python: Plot stars from the HYG data

Plots stars on the inside of a sphere using three different types of solids. Most stars are tetrahedrons, brighter stars are octahedrons and the brightest stars are plotted as dodecahedrons. ps. feel free to use this however you want but please don't republish the code as I don't want multiple copies all over the internet as I am likely to update this script every now and then... oh and if you make a million dollars out of it somehow, be sure to donate some of that money to the needy. If I ever find a file hosting service that I like, I'll post the completed .blend file there to save the trouble of running it seeing how the whole catalog can take six or more hours to run...

#!/usr/local/bin/python
#
# $Header: /home/zero/Blender/SOL-Centered-Starsphere-solid/RCS/starsphere-sol-solid-010.py,v 1.21 2015/01/31 03:35:33 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
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 = 8.0 # Takes about thirty-five minutes
skip_mag = 8.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
use_sphere = 1

# Stars will be plotted on the inside "surface" of an imarginary sphere
# with a radius this big
sphere_size = 2000

#----------------------------------------------------------------------------
# create mesh using visual magnitude
def create_star_solid(mesh,mag):
    # A tetrahedron
    # adjust for Sirius (the brightest star) it will be factor=0
    factor = mag + 1.44
    # now reverse the scale of size, Sirius will be of factor=2.2
    factor = (faintest - factor) / 10
    # now exaggerate the difference
    # TODO (should be the 2.5 times brighter for each magnitude)
    factor = factor * factor * factor

    # 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)

    mesh.from_pydata(verts, [], faces)
    mesh.update()

    return

# 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

#----------------------------------------------------------------------------
# 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 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(parent,spectral_type,mag,x,y,z,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 = parent

    # set location
    star_object.location = (x, y, z)

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

    # create less complex objects for dimmer stars
    create_star_solid(star_mesh, mag)

    # set the object origin, assumes the cursor is at 0,0,0
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

    # 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")

    spectral_type_material = bpy.data.materials.get(spectral_type)

    # Set object material
    if spectral_type_material is None:
        spectral_type_material = bpy.data.materials.new(spectral_type)
        star_object.data.materials.append(spectral_type_material)

        # 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): diffuse = ( 1.00, 0.00 + (int(s_n) / 20.0), 0.00 ) 
        elif k_regex.search(s_l): diffuse = ( 1.00, 0.50 + (int(s_n) / 20.0), 0.00 )
        elif g_regex.search(s_l): diffuse = ( 1.00, 1.00, 0.00 + (int(s_n) / 20.0) )
        elif f_regex.search(s_l): diffuse = ( 1.00, 1.00, 0.50 + (int(s_n) / 20.0) )
        elif a_regex.search(s_l): diffuse = ( 1.00 - (int(s_n) / 40.0), 1.00 - (int(s_n) / 40.0), 1.00 )
        elif b_regex.search(s_l): diffuse = ( 0.75 - (int(s_n) / 40.0), 0.75 - (int(s_n) / 40.0), 1.00 )
        elif o_regex.search(s_l): diffuse = ( 0.50 - (int(s_n) / 80.0), 0.50 - (int(s_n) / 80.0), 1.00 )
        else: diffuse = ( 1.00, 1.00, 1.00 )

        # use the colour we established above
        spectral_type_material.diffuse_color = diffuse
        # specular colour isn't used but set it anyway
        spectral_type_material.specular_color = diffuse

        # turn on emit
        spectral_type_material.emit = 1

        # set various material properties that we aren't really interested
        # in ie. we don't have want to use the specular 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
        spectral_type_material.use_cast_shadows = 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
    if len(star_object.name) != 2:
        # 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_star_on_sphere(starfield_parent, spectral_type, mag, RA, DEC):
    PHI = radians(RA * 15)
    THETA = radians(DEC)
    RHO = sphere_size

    if debug > 4:
        print('RHO={} THETA={} PHI={} Mag={} Spectrum={} RA={} DEC={}'.format(
            RHO, THETA, PHI, mag, spectrum, RA, DEC))

    RVECT = RHO * cos(THETA)
    x = RVECT * cos(PHI)
    y = RVECT * sin(PHI)
    z = RHO * sin(THETA)

    # Add the star solid
    create_star_object(starfield_parent, spectral_type, mag, x, y, z, RA, DEC)

    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)")

# 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()

# 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 = "STARCAM"
# 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 = "StarSphere"

#-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': 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 debug > 5 and mag > 1.0: continue
        if mag > 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

        x = float(f[17])
        y = float(f[18])
        z = float(f[19])

        if use_sphere > 0: plot_star_on_sphere(starfield_parent, spectral_type, mag, RA, DEC)
        else:
            if debug > 1:
                print('Star rejected ProperName={} Mag={} AbsMag={} Spectrum={} x={} y={} z={}'.format(
                    propername, mag, absmag, spectrum, x, y, z))


        pass
    # this is called when the line is a dud
    except:
        if debug: print("something failed: input line was ", myline)
        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')

Blender/Python: creating a tetrahedron

creating a tetrahedron in Python for blender (Code extracted from larger code available all over the interwebs ie. it is hard to give an actual source)

import math
import bpy


s = math.sqrt(2)/3.0
t = -1/3
u = math.sqrt(6)/3

# create tetrahedron with centre of mass being at Z=0
verts = [(0,0,1),
         (2*s,0,t),
         (-s,u,t),
         (-s,-u,t)]
faces = [[0,1,2],[0,2,3],[0,3,1],[1,3,2]]

# create another one where the base is at Z=0
#verts = [( 0.0, -1.0 / math.sqrt(3),       0.0),
#         ( 0.5,  1.0 / (2.0 * math.sqrt(3)), 0.0),
#         (-0.5,  1.0 / (2.0 * math.sqrt(3)), 0.0),
#         ( 0.0,  0.0, math.sqrt(2 / 3))]
#faces = [[0, 1, 2], [0, 1, 3], [1, 2, 3], [2, 0, 3]]

mesh = bpy.data.meshes.new("Tetrahedron")
mesh.from_pydata(verts, [], faces)
mesh.update()
obj = bpy.data.objects.new("Tetrahedron", mesh)
bpy.context.scene.objects.link(obj)

WHOIS caching proxy in perl

#!/usr/bin/perl
#
# $Header: /usr/local/etc/RCS/whois-proxy.pl,v 1.8 2014/11/04 22:47:28 mwd Exp $
#
# WHOIS caching proxy
#
#-----------------------------------------------------------------------
my $VERSION = substr( q$Revision: 1.8 $, 10 );

package Whois {
    use strict;
    use warnings;
    use POSIX qw( strftime );

    use parent 'Net::Server::PreFork';

    use Net::Whois::Proxy;
    use Cache::FileCache;
    use Net::IP::Match::XS;
    use Net::CIDR;

    my $debug = 1;

    logstderr("starting $0 ( v$VERSION)") if ($debug);

    sub whois_query {

        my $request = shift;
        my $expires = '';
        my $created = '';

        # default the lookup key to the original request, that way
        # if we can't find a proper key to use, we fall back to
        # the original request just so we don't waste the lookup.
        # ie. at the very least, if we lookup this address again,
        # it will be cached using itself as a key
        my $key = $request;
        my $whois_body_cache =
          new Cache::FileCache(
                                {'namespace'          => 'WHOIS_cache',
                                 'default_expires_in' => '7 days'} );

        foreach my $cache_key ( $whois_body_cache->get_keys() ) {
            logstderr("cache_key==$cache_key") if ( $debug > 5 );
            if ( my $match_key = match_ip( $request, $cache_key ) ) {
                logstderr("using MATCHED KEY $cache_key for $request") if ( $debug > 1 );
                $key = $cache_key;
            } else {
                logstderr("$request did NOT match $cache_key") if ( $debug > 4 );
            }
        }

        # Get the body based on the original IP address we were given
        my $body = $whois_body_cache->get($key);

        # Didn't get a cache hit? do the WHOIS lookup from scratch
        if ( not defined $body ) {
            my $whois = Net::Whois::Proxy->new( debug => 0, stacked_results => 1, clean_stack => 1 );

            logstderr("looking up $request from remote WHOIS databases") if ($debug);
            $body = $whois->whois($request);

            if ( !$body ) {
                $body = $whois->errstr;
            } else {

                my $netaddresses = '';
                my %CIDRs        = ();

                # Step thru and extract all things that look like a CIDR or a NETRANGE
                # and then see which one is the best match for the requested IP address
                # BEST MATCH will most likely be the CIDR/mask where the mask is the largest
                # integer that still matches that subnet
                # 161.143.0.0 - 161.143.255.255
                # 18.0.0.0/8
                # 14.0.0/8
                # 10.0/8
                # 55/8 # Hopefully we  don't get these
                while ( $body =~
m!(\d+\.\d+\.\d+\.\d+\s+\-\s+\d+\.\d+\.\d+\.\d+)|(\d+\.\d+\.\d+\.\d+/\d+)|(\d+\.\d+\.\d+/\d+)|(\d+\.\d+/\d+)|(\d+/\d+)!osmg
                  ) {
                    my ( $netrange, $full_cidr, $ctype_cidr, $btype_cidr, $atype_cidr ) =
                      ( $1, $2, $3, $4 );

                    if ( defined $netrange ) {
                        logstderr("FOUND NETRANGE $netrange");

                        # convert NETRANGE to CIDR
                        foreach my $range_cidr ( Net::CIDR::range2cidr($netrange) ) {
                            if ( $range_cidr =~ m!(\d+\.\d+\.\d+\.\d+)/(\d+)!o ) {
                                logstderr("FOUND FULL CIDR FROM NETRANGE $range_cidr");
                                my ( $full, $mask ) = ( $1, $2 );
                                $full_cidr = "$full/$mask";
                                $CIDRs{$full_cidr} = $mask;
                            }
                        }
                    } elsif ( defined $full_cidr ) {
                        logstderr("FOUND FULL CIDR $full_cidr");
                        if ( $full_cidr =~ m!(\d+\.\d+\.\d+\.\d+)/(\d+)!o ) {
                            my ( $full, $mask ) = ( $1, $2 );
                            $full_cidr = "$full/$mask";
                            $CIDRs{$full_cidr} = $mask;
                        }
                    } elsif ( defined $ctype_cidr ) {
                        logstderr("FOUND CTYPE CIDR $ctype_cidr");
                        if ( $ctype_cidr =~ m!(\d+\.\d+\.\d+)/(\d+)!o ) {
                            my ( $c, $mask ) = ( $1, $2 );
                            $ctype_cidr = "$c.0/$mask";
                            $CIDRs{$ctype_cidr} = $mask;
                        }
                    } elsif ( defined $btype_cidr ) {
                        logstderr("FOUND BTYPE CIDR $btype_cidr");
                        if ( $btype_cidr =~ m!(\d+\.\d+)/(\d+)!o ) {
                            my ( $b, $mask ) = ( $1, $2 );
                            $btype_cidr = "$b.0.0/$mask";
                            $CIDRs{$btype_cidr} = $mask;
                        }
                    } elsif ( defined $atype_cidr ) {
                        logstderr("FOUND ATYPE CIDR $atype_cidr");
                        if ( $atype_cidr =~ m!(\d+)/(\d+)!o ) {
                            my ( $a, $mask ) = ( $1, $2 );
                            $atype_cidr = "$a.0.0.0/$mask";
                            $CIDRs{$atype_cidr} = $mask;
                        }
                    }
                } ## end while ( $body =~ ...)

                # Step thru all the CIDRs sorting by highest bit mask first.
                # the address we want as a key, will be the CIDR that first
                # matches the highest netmask
                foreach my $cidr_key ( sort { $CIDRs{$b} <=> $CIDRs{$a} } keys %CIDRs ) {

                    # if the bitmask is greater than 32 we bail out - no CIDR bit masks are greater
                    # than 32 - at least in IPv4 and we only handle IPv4 so....
                    next if ( $CIDRs{$cidr_key} > 32 );

                    $netaddresses .= "$cidr_key, ";

                    logstderr("$cidr_key==$CIDRs{$cidr_key}") if ( $debug > 2 );

                    # if we get a match, set the key to this CIDR and skip the rest of the foreach loop
                    if ( my $match_key = match_ip( $request, $cidr_key ) ) {
                        logstderr("setting key for $request as $cidr_key");
                        $key = $cidr_key;

                        # BAIL out of the loop, we found what we are looking for...
                        last;
                    }

                } ## end foreach my $cidr_key ( sort...)

                # Chop off the final ", "
                $netaddresses =~ s!,\s+$!!soig;
                ##die $netaddresses;

            } ## end else [ if ( !$body ) ]

            $whois_body_cache->set( $key, $body );
        } else {
            logstderr("serving up cached request for $request with $key") if ($debug);
        }

        my $object = $whois_body_cache->get_object($key);
        $expires = $object->get_expires_at();
        $created = $object->get_created_at();

        return ( $body, $key, $expires || '', $created || '' );

    } ## end sub whois_query

    sub process_request {
        ( my $request = <> ) =~ s/[.]([^.]+)\x{0d}\x{0a}/.$1/;
        my ( $mybody, $mykey, $myexpires, $mycreated ) = whois_query($request);

       #print "pid=$$ request=$request key=$mykey expires=$myexpires created=$mycreated\r\n$mybody\r\n";
        printf "pid=%d request=%s key=%s expires=%s created=%s\r\n%s\r\n",
          $$, $request, $mykey, fmttime($myexpires), fmttime($mycreated), $mybody;
    }

    sub fmttime {
        my $thistime = shift;
        return ( strftime "%Y/%m/%d-%H:%M:%S", localtime($thistime) );
    }

    sub logstderr {
        my $msg = shift;

        #my $timestring = strftime "%Y/%m/%d-%H:%M:%S", localtime;
        printf STDERR "%s %s\n", fmttime( time() ), $msg;
    }

} ## end package Whois

Whois->run( user              => "nobody",
            group             => "nobody",
            port              => 43,
            min_servers       => 1,              #min number of children
            max_servers       => 5,              #max number of children
            min_spare_servers => 1,              #fork if we don't have this many waiting
            max_spare_servers => 2,              #kill if we have this many waiting
            max_requests      => 10_000,         #num of requests before killing a child
            );

Sonic Wall Status - Nagios plugin

#!/usr/local/bin/perl -w

use strict;
use Getopt::Long;
use lib "/usr/local/libexec/nagios";
use utils qw(%ERRORS &print_revision &support &usage );

#-clean-environment---------------------------------------------------------

$ENV{'PATH'}     = '';
$ENV{'BASH_ENV'} = '';
$ENV{'ENV'}      = '';

#-globals-------------------------------------------------------------------

my $PROGNAME = $0;

my $SONICWALLBASEMIB = '.1.3.6.1.4.1.8741';

my $opt_snmpwalk = '/usr/local/bin/snmpwalk';

my $opt_community = 'public';
my $opt_hostname  = '';

my $opt_debug    = 0;
my $opt_help     = 0;
my $opt_version  = 0;
my $opt_warning  = 0;
my $opt_critical = 0;

my $msg         = '';
my $exit_status = $ERRORS{'OK'};

my $USAGE = qq{
Usage:

  $PROGNAME [-d] [-v] [-?] [-h hostname] [-s community]

};

#-options-processing--------------------------------------------------------

GetOptions( 'debug|d+'      => \$opt_debug,
            'help|?'        => \$opt_help,
            'v|version'     => \$opt_version,
            'w|warning=i'   => \$opt_warning,
            'c|critical=i'  => \$opt_critical,
            's|community=s' => \$opt_community,
            'h|hostname=s'  => \$opt_hostname, );

if ($opt_help) { print $USAGE; exit $ERRORS{'OK'}; }
if ($opt_version) { printf '%s: %s', $PROGNAME, '$Revision: 1.13 $'; exit $ERRORS{'OK'}; }

die "hostname parameter required:\n$USAGE" if ( $opt_hostname eq '' );

#---------------------------------------------------------------------------
## flogster:/ # snmpwalk -OnQ -v2c -c public sonicfirewall .1.3.6.1.4.1.8741
## .1.3.6.1.4.1.8741.1.3.1.1.0 = 131250
## .1.3.6.1.4.1.8741.1.3.1.2.0 = 17734
## .1.3.6.1.4.1.8741.1.3.1.3.0 = 14
## .1.3.6.1.4.1.8741.1.3.1.4.0 = 20
## .1.3.6.1.4.1.8741.2.1.1.1.0 = "NSA 3600"
## .1.3.6.1.4.1.8741.2.1.1.2.0 = "70CAD38EF8BA"
## .1.3.6.1.4.1.8741.2.1.1.3.0 = "SonicOS Enhanced 6.1.1.5-19n"
## .1.3.6.1.4.1.8741.2.1.1.4.0 = "5.4.1.0"

my $snmpwalk = "$opt_snmpwalk -OnQ -v2c -c $opt_community $opt_hostname $SONICWALLBASEMIB";

my %MIBs = ();

open( SNMPWALK, "$snmpwalk|" ) or die "$!: $snmpwalk";
while (<SNMPWALK>) {
    if (m!^(\S+)\s+=\s+(.*?)$!soig) {
        my ( $key, $value ) = ( $1, $2 );
        $value =~ s!"!!soig;        # we don't want them
        print "KEY=$key VALUE=$value\n" if ($opt_debug);
        $MIBs{$key} = $value;
    }
}

my $connpercent = $MIBs{".1.3.6.1.4.1.8741.1.3.1.2.0"} / $MIBs{".1.3.6.1.4.1.8741.1.3.1.1.0"} * 100;
my $status      = 'OK';

# CRITICAL
if (    ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"} > $opt_critical )
     || ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"} > $opt_critical )
     || ( $connpercent > $opt_critical ) ) {

    $status = 'CRITICAL';
    $exit_status = $ERRORS{'CRITICAL'};

} elsif (    ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"} > $opt_warning )
          || ( $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"} > $opt_warning )
          || ( $connpercent > $opt_warning ) ) {

    $status = 'WARNING';
    $exit_status = $ERRORS{'WARNING'};

} else {

    $status = 'OK';
    $exit_status = $ERRORS{'OK'};

}

my $perfdata = sprintf "cpu=%d%%;;;; memory=%d%%;;;; currconn=%d;;;;%d",
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.2.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.1.0"};

printf "$status - CPU=%d%%, MEMORY=%d%%, CONNS=%d%%, model=%s, serial=%s, firmware=%s, rom=%s",
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.1.3.1.4.0"},
  $connpercent,
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.1.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.2.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.3.0"},
  $MIBs{".1.3.6.1.4.1.8741.2.1.1.4.0"};

print '|' . $perfdata . "\n";

exit $exit_status;

__END__