#!/usr/bin/env python
# coding: UTF-8
#
## Class for handling the mapping from window coordinates
#  to viewport coordinates.
#
#  @author Paulo Roma
#  @date 10/08/2019
#
import sys

class mapper:
    ## Constructor.
    #
    #  @param world window rectangle.
    #  @param viewport screen rectangle.
    #  @param ydown whether Y axis is upside down.
    #  @param noDistortion whether to use the same scale for both X and Y.
    #
    def __init__(self, world, viewport, ydown=True, noDistortion=True):
        self.world = world
        self.viewport = viewport
        x_min, y_min, x_max, y_max = self.world[:4]
        X_min, Y_min, X_max, Y_max = self.viewport[:4]
        self.fx = float(X_max - X_min) / float(x_max - x_min)
        self.fy = float(Y_max - Y_min) / float(y_max - y_min)
        self.ys = -1 if ydown else 1

        if noDistortion:
            self.f = min(self.fx, self.fy)
            self.fx = self.fy = self.f

        x_c = 0.5 * (x_min + x_max)
        y_c = 0.5 * (y_min + y_max)
        X_c = 0.5 * (X_min + X_max)
        Y_c = 0.5 * (Y_min + Y_max)
        self.c_1 = X_c - self.fx * x_c
        self.c_2 = Y_c - self.fy * y_c

    ## Maps a single point from world coordinates to viewport (screen) coordinates.
    #
    #  @param x, y given point.
    #  @return a new point in screen coordinates.
    #
    def __windowToViewport(self, x, y):
        X = round(self.fx * x + self.c_1)
        Y = round(self.fy * self.ys * y + self.c_2)  # Y axis maybe upside down
        return X, Y

    ## Maps a single vector from world coordinates to viewport (screen) coordinates.
    #
    #  @param x, y given vector.
    #  @return a new vector in screen coordinates.
    #
    def windowVecToViewport(self, x, y):
        X = round(self.fx * x)
        Y = round(self.fy * self.ys * y)  # Y axis maybe upside down
        return X, Y

    ## Maps a single point from screen coordinates to window (world) coordinates.
    #
    #  @param x, y given point.
    #  @return a new point in world coordinates.
    #
    def viewportToWindow(self, x, y):
        X = (x - self.c_1) / self.fx
        Y = (y - self.c_2) / self.fy
        return X, Y

    ## Maps points from world coordinates to viewport (screen) coordinates.
    #
    #  @param p a variable number of points.
    #  @return two new points in screen coordinates.
    #
    def windowToViewport(self, *p):
        return [self.__windowToViewport(x[0], x[1]) for x in p]

def main():
    # maps the unit rectangle onto a viewport of 400x400 pixels.
    map = mapper([-1, -1, 1, 1], [0, 0, 400, 400])
    p1, p2 = map.windowToViewport((0, 0), (1, 1))
    p = map.viewportToWindow(400, 400)
    print("%s - %s" % (p1, p2))  # (200, 200) - (400, 0)
    print("(%d,%d)" % p)       # (1,1)


if __name__ == "__main__":
    sys.exit(main())