399 lines
12 KiB
Python
399 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
# Distributed under the terms of the GNU Lesser General Public License v3.0
|
|
### Author: Neon22 - github 2016
|
|
|
|
### fret scale calculation code
|
|
|
|
from math import log, floor
|
|
|
|
def fret_calc_ratio(length, howmany, ratio):
|
|
" given the ratio between notes, calc distance between frets "
|
|
# typically 18, 17.817, 17.835 for equal temperment scales
|
|
distances = []
|
|
prev = 0
|
|
for i in range(howmany):
|
|
distance = length / ratio
|
|
distances.append(prev+distance)
|
|
length -= distance
|
|
prev += distance
|
|
# print "%02d %6.4f %s" %(i, prev, distance)
|
|
return distances
|
|
|
|
def fret_calc_root2(length, howmany, numtones=12):
|
|
" using Nroot2 method, calc distance between frets "
|
|
distances = []
|
|
for i in range(howmany):
|
|
# Calculating Fret Spacing for a Single Fret
|
|
# d = s-(s/ (2^ (n/12)))
|
|
distance = length - (length / (pow(2, (i+1)/(float(numtones))) ))
|
|
distances.append(distance)
|
|
# print "%02d %6.4f" %(i, distance)
|
|
return distances
|
|
|
|
def fret_calc_scala(length, howmany, scala_notes):
|
|
" use ratios from scala file, calc distance between frets "
|
|
distances = []
|
|
for i in range(howmany):
|
|
if i < len(scala_notes):
|
|
r = scala_notes[i]
|
|
else:
|
|
end = pow(scala_notes[-1], int(i / float(len(scala_notes))))
|
|
r = end * scala_notes[i%len(scala_notes)]
|
|
distance = length - (length / r)
|
|
distances.append(distance)
|
|
return distances
|
|
|
|
def cents_to_ratio(cents):
|
|
" given a value in cents, calculate the ratio "
|
|
return pow(2, cents / 1200.0)
|
|
|
|
def parse_scala(scala, filename, verbose=True):
|
|
""" Parse the readlines() from scala file into:
|
|
- description, numnotes,
|
|
- lists of pretty ratios, numeric ratios
|
|
"""
|
|
description = ""
|
|
numnotes = 0
|
|
notes = []
|
|
ratios = []
|
|
error = False
|
|
# print scala
|
|
for line in scala:
|
|
try:
|
|
# take out leading and trailing spaces - get everything up to first space if exists
|
|
line = line.strip() # hold onto this for when we need the description
|
|
first = line.split()[0] # first element in the line
|
|
# print line
|
|
if first and first[0] != "!": # ignore all blank and comment lines
|
|
if not description:
|
|
# expecting description line first
|
|
# may contain unprintable characters - force into unicode
|
|
description = unicode(line, errors='ignore')
|
|
elif numnotes == 0:
|
|
# expecting notes count after description
|
|
numnotes = int(first)
|
|
else: # expecting sequences of notes
|
|
notes.append(first) # for later ref
|
|
# remove comments at end of line if exist
|
|
if first.count("!") > 0:
|
|
first = first[:first.find("!")]
|
|
if first.find('.') > -1: # cents
|
|
ratios.append(cents_to_ratio(float(first)))
|
|
elif first.find("/") > -1: # ratio
|
|
num, denom = first.split('/')
|
|
ratios.append(int(num)/float(denom))
|
|
else:
|
|
ratios.append(int(first))
|
|
except:
|
|
error = "ERROR: Failed to load "+filename
|
|
#
|
|
if verbose:
|
|
print ("Found:", description)
|
|
print ("",numnotes, "notes found.")
|
|
for n,r in zip(notes,ratios):
|
|
print (" %4.4f : %s"%(r, n))
|
|
print (" check: indicated=found : %d=%d"%(numnotes,len(notes)))
|
|
if error:
|
|
return [error, numnotes, notes, ratios]
|
|
else:
|
|
return [description, numnotes, notes, ratios]
|
|
|
|
def read_scala(filename, verbose=False):
|
|
" read and parse scala file into interval ratios "
|
|
try:
|
|
inf = open(filename, 'rB')
|
|
content = inf.readlines()
|
|
inf.close()
|
|
flag = verbose
|
|
# if filename.find("dyadic") > -1: flag = True
|
|
return parse_scala(content, filename, flag)
|
|
except:
|
|
return ["ERROR: Failed to load "+filename, 2, [1], [1.01]]
|
|
|
|
|
|
### frequency to note
|
|
def log_note(freq):
|
|
" find the octave the note is in "
|
|
octave = (log(freq) - log(261.626)) / log (2) + 4.0
|
|
return octave
|
|
|
|
def freq_to_note(freq):
|
|
lnote = log_note(freq)
|
|
octave = floor(lnote)
|
|
cents = 1200 * (lnote - octave)
|
|
notes = ['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
|
|
offset = 50.0
|
|
x = 1
|
|
if cents < 50:
|
|
note = "C"
|
|
elif cents >= 1150:
|
|
note = "C"
|
|
cents -= 1200
|
|
octave += 1
|
|
else:
|
|
for j in range(1,12):
|
|
if offset <= cents < (offset + 100):
|
|
note = notes[x]
|
|
cents -= (j * 100)
|
|
break
|
|
offset += 100
|
|
x += 1
|
|
return "%s%d"%(note, int(octave)), "%4.2f"%(cents)
|
|
|
|
|
|
def int_or_float(value):
|
|
" true if value is an int or a float "
|
|
return type(value) == type(1) or type(value) == type(1.0)
|
|
|
|
|
|
### class to hold info about instrument necks
|
|
class Neck(object):
|
|
def __init__(self, length, strings=['G','C','E','A'], units='in', spacing=0.4, fret_width=1.5):
|
|
" "
|
|
# coerce single spacing value into a list of nut/bridge spacing
|
|
self.set_spacing(spacing)
|
|
# same for fret_width
|
|
self.set_width(fret_width)
|
|
#
|
|
self.length = length
|
|
self.strings = strings
|
|
self.units = units
|
|
self.frets = [] # Treble side frets if fanned
|
|
self.bass_frets =[]
|
|
self.fanned = False
|
|
self.bass_scale = 0
|
|
self.fanned_vertical = False
|
|
self.method = '12root2'
|
|
self.notes_in_scale = False
|
|
# Scala
|
|
self.scala = False
|
|
self.description = False
|
|
self.scala_notes = False
|
|
self.scala_ratios = False
|
|
def __repr__(self):
|
|
extra = ""
|
|
if len(self.frets)>0:
|
|
extra += "%d frets"%(len(self.frets))
|
|
if self.method == 'scala':
|
|
extra += "(%s)" %(self.scala.split('/')[-1]) # filename
|
|
return "<Neck: %s -%4.2f(%s) %s %d strings>"%(self.method, self.length, self.units, extra, len(self.strings))
|
|
|
|
def set_width(self, fret_width):
|
|
" get both values from this "
|
|
if int_or_float(fret_width):
|
|
fret_width = [fret_width,fret_width]
|
|
elif type(fret_width) != type([]):
|
|
fret_width = [1,1]
|
|
self.nut_width = fret_width[0]
|
|
self.bridge_width = fret_width[1]
|
|
|
|
def set_spacing(self, spacing):
|
|
" get both values from this "
|
|
if int_or_float(spacing):
|
|
spacing = [spacing,spacing]
|
|
elif type(spacing) != type([]):
|
|
spacing = [1,1]
|
|
self.nut_spacing = spacing[0]
|
|
self.bridge_spacing = spacing[1]
|
|
|
|
def set_fanned(self, bass_scale, vertical_fret):
|
|
""" keep existing treble calc and create Bass calc
|
|
- must have called calc_fret_offsets() before
|
|
(so notes_in_scale is set)
|
|
"""
|
|
# adjust the position of the treble side if required.
|
|
# calc fret_offset and if treble or bass side needs to be moved
|
|
# if treble - move self.frets
|
|
# if bass, add offset as calculated
|
|
treble = self.frets
|
|
# print treble
|
|
if self.method == 'scala':
|
|
bass = self.calc_fret_offsets(bass_scale, len(self.frets), method=self.method, scala_filename=self.scala)
|
|
else:
|
|
bass = self.calc_fret_offsets(bass_scale, len(self.frets), method=self.method, numtones=self.notes_in_scale)
|
|
offset = 0 if vertical_fret ==0 else bass[vertical_fret - 1] - treble[vertical_fret - 1]
|
|
# print "offset", offset, "bass",bass
|
|
if offset > 0:
|
|
# shift treble
|
|
for i in range(len(treble)):
|
|
treble[i] += offset
|
|
else: # shift bass
|
|
for i in range(len(bass)):
|
|
bass[i] -= offset
|
|
self.frets = treble
|
|
self.bass_frets = bass
|
|
self.bass_scale = bass_scale
|
|
self.fanned_vertical = vertical_fret
|
|
self.fan_offset = offset
|
|
self.fanned = True
|
|
return offset
|
|
|
|
def find_mid_point(self, fret_index, width_offset):
|
|
""" find midpoint of fret, fret-1 along neck
|
|
and ///y width where width_offset=0 means center of neck
|
|
"""
|
|
y_factor = (width_offset + self.nut_width/2) / float(self.nut_width)
|
|
# assume fanned
|
|
tpos_f1 = self.frets[fret_index]
|
|
bpos_f1 = tpos_f1 if not self.fanned else self.bass_frets[fret_index]
|
|
if self.fanned:
|
|
if self.fan_offset >= 0:
|
|
tpos_f0 = self.fan_offset if fret_index<=1 else self.frets[fret_index-1]
|
|
bpos_f0 = 0 if fret_index<=1 else self.bass_frets[fret_index-1]
|
|
else:
|
|
bpos_f0 = -self.fan_offset if fret_index<=1 else self.bass_frets[fret_index-1]
|
|
tpos_f0 = 0 if fret_index<=1 else self.frets[fret_index-1]
|
|
else:
|
|
tpos_f0 = 0 if fret_index<=1 else self.frets[fret_index-1]
|
|
bpos_f0 = 0 if fret_index<=1 else tpos_f0
|
|
#
|
|
mid_tpos = tpos_f0 + (tpos_f1 - tpos_f0)/2
|
|
mid_bpos = bpos_f0 + (bpos_f1 - bpos_f0)/2
|
|
# print fret_index, y_factor
|
|
# print " %4.2f %4.2f %4.2f"% (tpos_f0, tpos_f1, mid_tpos)
|
|
# print " %4.2f %4.2f %4.2f"% (bpos_f0, bpos_f1, mid_bpos)
|
|
# the mid_xx positions are self.nut_width apart
|
|
return [mid_tpos + (mid_bpos-mid_tpos)*y_factor, width_offset/self.nut_width*1.5]
|
|
|
|
def calc_fret_offsets(self, length, howmany, method='12root2', numtones=12, scala_filename=False):
|
|
" calc fret positions from Nut for all methods "
|
|
frets = False # store them in here
|
|
if scala_filename:
|
|
scala_notes = read_scala(scala_filename)
|
|
self.method = 'scala'
|
|
self.scala = scala_filename
|
|
self.description = scala_notes[0]
|
|
self.scala_notes = scala_notes[2]
|
|
self.scala_ratios = scala_notes[3] # [-1]
|
|
frets = fret_calc_scala(length, howmany, self.scala_ratios)
|
|
self.notes_in_scale = len(self.scala_ratios)
|
|
elif method.find('root2') > -1:
|
|
self.method = method
|
|
frets = fret_calc_root2(length, howmany, numtones)
|
|
self.notes_in_scale = numtones
|
|
elif method == '18':
|
|
self.method = method
|
|
ratio = 18
|
|
frets = fret_calc_ratio(length, howmany, ratio)
|
|
self.notes_in_scale = 12
|
|
elif method == '17.817':
|
|
self.method = method
|
|
ratio = 17.81715374510580
|
|
frets = fret_calc_ratio(length, howmany, ratio)
|
|
self.notes_in_scale = 12
|
|
elif method == '17.835':
|
|
self.method = method
|
|
ratio = 17.835
|
|
frets = fret_calc_ratio(length, howmany, ratio)
|
|
self.notes_in_scale = 12
|
|
# update the iv
|
|
self.frets = frets
|
|
return frets
|
|
|
|
def show_frets(self):
|
|
" pretty print "
|
|
for i,d in enumerate(self.frets):
|
|
print ("%2d: %4.4f" %(i+1,d))
|
|
if self.bass_frets:
|
|
for i,d in enumerate(self.bass_frets):
|
|
print ("%2d: %4.4f" %(i+1,d))
|
|
|
|
def compare_methods(self, howmany, verbose=True):
|
|
" show differences in length for the main methods (not scala) "
|
|
distances = []
|
|
differences = []
|
|
methods = ['12root2', '18', '17.817', '17.835']
|
|
n = Neck(30) # long one to maximise errors
|
|
for method in methods:
|
|
distances.append(n.calc_fret_offsets(n.length, howmany, method))
|
|
# print distances[-1]
|
|
for i in range(1, len(methods)):
|
|
differences.append( [a-b for (a,b) in zip(distances[0], distances[i])] )
|
|
if verbose:
|
|
print("Differences from 12root2")
|
|
for i,m in enumerate(methods[1:]):
|
|
print ("\nMethod = %s\n " %(m))
|
|
for d in differences[i]:
|
|
print ("%2.3f " %(d))
|
|
print("")
|
|
# package
|
|
combined = []
|
|
for i,m in enumerate(methods[1:]):
|
|
combined.append([m, max(differences[i]), differences[i]])
|
|
return combined
|
|
|
|
# Gibson "rule of 18" base scale is in sys 18.
|
|
# Martin 24.9 (24.84), 25.4 (act 25.34) rough approx and round up. not actually the scale length
|
|
# The difference between 17.817 and 17.835 came from rounding early and carrying the roundoff error through the rest of the work.
|
|
# where r = twelfth root of two and put the first fret where it would make the sounding length of the string 1/r of its original length
|
|
|
|
|
|
### tests
|
|
if __name__ == "__main__":
|
|
n = Neck(24)
|
|
f = n.calc_fret_offsets(n.length, 12, '12root2')
|
|
n.show_frets()
|
|
print (n)
|
|
errors = n.compare_methods(22, False)
|
|
for m,e,d in errors:
|
|
print ("for method '%s': max difference from 12Root2 = %4.3f%s (on highest fret)"%(m,e, n.units))
|
|
#
|
|
n = Neck(24)
|
|
f = n.calc_fret_offsets(n.length, 22, 'scala', scala_filename='scales/diat_chrom.scl')
|
|
n.show_frets()
|
|
print ("Fanning")
|
|
# n.set_fanned(25,0)
|
|
# n.show_frets()
|
|
# print n
|
|
# print n.description
|
|
# print n.scala
|
|
# print n.scala_notes
|
|
# print n.scala_ratios
|
|
|
|
# similar to scale=10 to scale = 9.94 but slightly diff neaer the nut.
|
|
|
|
# scala_notes = read_scala("scales/alembert2.scl")#, True)
|
|
# print "Notes=",len(scala_notes[-1]), scala_notes[1]
|
|
# for d in fret_calc_scala(24, scala_notes[-1]): print d
|
|
|
|
# test load all scala files
|
|
# import os
|
|
# probable_dir = "scales/"
|
|
# files = os.listdir(probable_dir)
|
|
# for f in files:
|
|
# fname = probable_dir+f
|
|
# # print f
|
|
# data = read_scala(fname)
|
|
# # print " ",data[0]
|
|
# if data[0][:5] == "ERROR":
|
|
# print "!!!! ERROR",fname
|
|
|
|
## freq conversion
|
|
print("")
|
|
for f in [440,443,456,457, 500,777, 1086]:
|
|
print (f, freq_to_note(f))
|
|
|
|
## fanned frets
|
|
# print
|
|
# for f in [1,11]:
|
|
# print n.find_mid_point(f,-0.75)
|
|
|
|
# get to this eventually
|
|
string_compensation = [
|
|
0.0086, 0.0119, 0.0107, 0.0124, 0.0151, 0.0175, 0.020, 0.0222, 0.0244, 0.0263,
|
|
0.0282, 0.030, 0.0371, 0.4235
|
|
]
|
|
|
|
### Optionally:
|
|
# how many strings,
|
|
# (associated sequence of intervals)
|
|
|
|
|
|
### refs:
|
|
#http://fretfocus.anastigmatix.net/
|
|
#http://windworld.com/features/tools-resources/exmis-fret-placement-calculator/
|
|
#http://www.huygens-fokker.org/scala/
|
|
|
|
# superstart:
|
|
# notes on the fretboard
|
|
# https://www.youtube.com/watch?v=-jW1Xx0t3ZI |