"""Scalar Feature Pyramid Network arithmetic, not a trained object detector.
Pinned source: arXiv:1612.03144v2. Standard library only; optional --json.
Learned 1x1 and 3x3 convolutions are replaced by supplied scalar scaling and a
fixed zero-padded mean. C2..C5 are supplied features, not computed backbone maps.
"""
import argparse
import json
import math


# region: upsample
def nearest_resize(values, height, width, target_height, target_width):
    """Use floor-index nearest sampling with explicit target shape for odd grids."""
    dims = (height, width, target_height, target_width)
    if any(not isinstance(v, int) or isinstance(v, bool) or v <= 0 for v in dims):
        raise ValueError("Dimensions must be positive integers")
    if len(values) != height*width or not all(math.isfinite(v) for v in values):
        raise ValueError("Feature shape/value mismatch")
    return [values[min(height-1, y*height//target_height)*width
                   + min(width-1, x*width//target_width)]
            for y in range(target_height) for x in range(target_width)]
# endregion: upsample


def smooth(values, height, width):
    """Fixed 3x3 mean, including zero padding, replaces learned output filters."""
    return [sum(values[(y+dy)*width+x+dx]
                for dy in (-1, 0, 1) for dx in (-1, 0, 1)
                if 0 <= y+dy < height and 0 <= x+dx < width)/9
            for y in range(height) for x in range(width)]


# region: fusion
def build_pyramid(levels, lateral=1.0, top_down=True):
    """Propagate inner maps; apply the 3x3 output operator after each merge."""
    if len(levels) != 4 or not math.isfinite(lateral):
        raise ValueError("Supply C2, C3, C4, C5 and finite lateral scale")
    output, higher = [None]*4, None
    for index in range(3, -1, -1):
        height, width, values = levels[index]
        projected = [lateral*v for v in nearest_resize(values, height, width,
                                                       height, width)]
        up = (nearest_resize(higher["inner"], higher["height"], higher["width"],
                             height, width) if higher and top_down
              else [0.0]*len(values))
        inner = [a+b for a, b in zip(projected, up)]
        higher = {"level": index+2, "height": height, "width": width,
                  "inner": inner, "values": smooth(inner, height, width)}
        output[index] = higher
    return output
# endregion: fusion


# region: assignment
def roi_level(width, height):
    """Assign Fast R-CNN RoIs to P2..P5; P6 belongs to the original RPN."""
    if not all(math.isfinite(v) and v > 0 for v in (width, height)):
        raise ValueError("Positive finite RoI extent required")
    scale = math.sqrt(width*height)
    raw = math.floor(4+math.log2(scale/224))
    return {"raw": raw, "level": min(5, max(2, raw)), "scale": scale}
# endregion: assignment


def self_check():
    assert nearest_resize([1, 2, 3, 4], 2, 2, 3, 5) == [1,1,1,2,2,1,1,1,2,2,3,3,3,4,4]
    levels = [(5, 7, [1]*35), (3, 4, [2]*12), (2, 2, [3]*4), (1, 1, [4])]
    pyramid = build_pyramid(levels)
    assert pyramid[0]["inner"] == [10]*35
    assert pyramid[0]["values"][17] == 10
    assert pyramid[0]["values"][0] == 40/9
    assert build_pyramid(levels, top_down=False)[0]["inner"] == [1]*35
    assert roi_level(224, 224)["level"] == 4
    assert roi_level(448, 448)["level"] == 5
    assert roi_level(1, 1)["level"] == 2
    assert roi_level(112, 448)["level"] == 4


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()
    self_check()
    levels = [(5, 7, [1]*35), (3, 4, [2]*12), (2, 2, [3]*4), (1, 1, [4])]
    report = {"kind": "analytical illustration", "pyramid": build_pyramid(levels),
              "assignments": [roi_level(s, s) for s in (32, 56, 112, 224, 448, 896)]}
    print(json.dumps(report, indent=2) if args.json else "FPN self-check passed: odd-grid resize, top-down addition, output smoothing and level assignment.")


if __name__ == "__main__":
    main()
