123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133 |
- #!/usr/bin/python
- '''
- Copyright 2013 Google Inc.
- Use of this source code is governed by a BSD-style license that can be
- found in the LICENSE file.
- '''
- import math
- import pprint
- def withinStdDev(n):
- """Returns the percent of samples within n std deviations of the normal."""
- return math.erf(n / math.sqrt(2))
- def withinStdDevRange(a, b):
- """Returns the percent of samples within the std deviation range a, b"""
- if b < a:
- return 0;
- if a < 0:
- if b < 0:
- return (withinStdDev(-a) - withinStdDev(-b)) / 2;
- else:
- return (withinStdDev(-a) + withinStdDev(b)) / 2;
- else:
- return (withinStdDev(b) - withinStdDev(a)) / 2;
- # We have some smudged samples which represent the average coverage of a range.
- # We have a 'center' which may not line up with those samples.
- # From center make a normal where 5 sample widths out is at 3 std deviations.
- # The first and last samples may not be fully covered.
- # This is the sub-sample shift for each set of FIR coefficients
- # (the centers of the lcds in the samples)
- # Each subpxl takes up 1/3 of a pixel,
- # so they are centered at x=(i/n+1/2n), or 1/6, 3/6, 5/6 of a pixel.
- # Each sample takes up 1/4 of a pixel,
- # so the results fall at (x*4)%1, or 2/3, 0, 1/3 of a sample.
- samples_per_pixel = 4
- subpxls_per_pixel = 3
- #sample_offsets is (frac, int) in sample units.
- sample_offsets = [
- math.modf(
- (float(subpxl_index)/subpxls_per_pixel + 1.0/(2.0*subpxls_per_pixel))
- * samples_per_pixel
- ) for subpxl_index in range(subpxls_per_pixel)
- ]
- #How many samples to consider to the left and right of the subpxl center.
- sample_units_width = 5
- #The std deviation at sample_units_width.
- std_dev_max = 3
- #The target sum is in some fixed point representation.
- #Values larger the 1 in fixed point simulate ink spread.
- target_sum = 0x110
- for sample_offset, sample_align in sample_offsets:
- coeffs = []
- coeffs_rounded = []
- #We start at sample_offset - sample_units_width
- current_sample_left = sample_offset - sample_units_width
- current_std_dev_left = -std_dev_max
- done = False
- while not done:
- current_sample_right = math.floor(current_sample_left + 1)
- if current_sample_right > sample_offset + sample_units_width:
- done = True
- current_sample_right = sample_offset + sample_units_width
- current_std_dev_right = current_std_dev_left + (
- (current_sample_right - current_sample_left) / sample_units_width
- ) * std_dev_max
- coverage = withinStdDevRange(current_std_dev_left, current_std_dev_right)
- coeffs.append(coverage * target_sum)
- coeffs_rounded.append(int(round(coverage * target_sum)))
- current_sample_left = current_sample_right
- current_std_dev_left = current_std_dev_right
- # Have the numbers, but rounding needs to add up to target_sum.
- delta = 0
- coeffs_rounded_sum = sum(coeffs_rounded)
- if coeffs_rounded_sum > target_sum:
- # The coeffs add up to too much.
- # Subtract 1 from the ones which were rounded up the most.
- delta = -1
- if coeffs_rounded_sum < target_sum:
- # The coeffs add up to too little.
- # Add 1 to the ones which were rounded down the most.
- delta = 1
- if delta:
- print "Initial sum is 0x%0.2X, adjusting." % (coeffs_rounded_sum,)
- coeff_diff = [(coeff_rounded - coeff) * delta
- for coeff, coeff_rounded in zip(coeffs, coeffs_rounded)]
- class IndexTracker:
- def __init__(self, index, item):
- self.index = index
- self.item = item
- def __lt__(self, other):
- return self.item < other.item
- def __repr__(self):
- return "arr[%d] == %s" % (self.index, repr(self.item))
- coeff_pkg = [IndexTracker(i, diff) for i, diff in enumerate(coeff_diff)]
- coeff_pkg.sort()
- # num_elements_to_force_round better be < (2 * sample_units_width + 1) or
- # * our math was wildy wrong
- # * an awful lot of the curve is out side our sample
- # either is pretty bad, and probably means the results will not be useful.
- num_elements_to_force_round = abs(coeffs_rounded_sum - target_sum)
- for i in xrange(num_elements_to_force_round):
- print "Adding %d to index %d to force round %f." % (
- delta, coeff_pkg[i].index, coeffs[coeff_pkg[i].index])
- coeffs_rounded[coeff_pkg[i].index] += delta
- print "Prepending %d 0x00 for allignment." % (sample_align,)
- coeffs_rounded_aligned = ([0] * int(sample_align)) + coeffs_rounded
- print ', '.join(["0x%0.2X" % coeff_rounded
- for coeff_rounded in coeffs_rounded_aligned])
- print sum(coeffs), hex(sum(coeffs_rounded))
- print
|