| #!/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. |
| ''' |
| |
| |
| from __future__ import print_function |
| 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() |