ProjectiveGeometry23 0.1.0__py3-none-any.whl

ProjectiveGeometry23/source_detector_geometry.py

@@ -0,0 +1,103 @@
+"""
+Computations on the detector in pixels and 3D millimeters of source-detector systems such as X-ray.
+
+Author: André Aichert
+Date: June 22, 2023
+"""
+
+import numpy as np
+from numpy.linalg import norm
+from .central_projection import ProjectionMatrix
+from .utils import cvec, append, dehomogenize
+
+class SourceDetectorGeometry:
+    def __init__(self, projection: ProjectionMatrix):
+        """From a 3x4 projection matrix and pixel spacing, compute physical location of detector.
+        This allows for a full visualization of a source-detector geometry as a pyramid or frustum.
+        In case you have a left-handed coordinate frame, use negative pixel spacing to swap the
+        viewing direction of the system (i.e. negate pixel spacing if projection looks backwards."""
+        projection.normalize()        
+        
+        C = projection.getCenterOfProjection()
+        
+        m1 = projection.P[0, :3]
+        m2 = projection.P[1, :3]
+        m3 = projection.P[2, :3]
+        
+        U = np.append(np.cross(m3, m2), 0)
+        V = np.append(np.cross(m3, m1), 0)
+
+        U *= projection.pixel_spacing / norm(U)
+        V *= projection.pixel_spacing / norm(V)
+        
+        principal_plane = projection.P[2, :4]
+        
+        # Note how this conversion is symmetric for U and V.
+        V_dir = V[:3] / projection.pixel_spacing
+        f = np.dot(m1, np.cross(V_dir, m3))
+        
+        # However, the results will be the same ONLY in the case of rectangular pixels.
+        # Assumption of rectangular pixels for a digital detector is pretty safe though.
+        image_plane = principal_plane.copy()
+        image_plane[3] -= f * projection.pixel_spacing
+        
+        # negative pixel spacings support flipping detector axes (left handed systems)
+        # Note how mulpiplication of a projection matrix with -1 inverts viewing direction.
+        # if projection.pixel_spacing < 0:
+        #   V *= -1
+        
+        central_projection = SourceDetectorGeometry.centralProjectionToPlane(C, image_plane)
+        
+        source_detector_distance = np.dot(image_plane, C)[0]
+        
+        principal_point_3d = cvec(C) - append(m3, 0) * source_detector_distance
+        
+        principal_point = np.dot(projection.P, principal_point_3d)
+        pp = principal_point / principal_point[2]
+        
+        # This is the corner of the detector where the pixel origin is located
+        detector_origin = principal_point_3d - cvec(U) * pp[0] - cvec(V) * pp[1]
+
+        # things that fully define the source-detector geometry:
+        self.source_position = C
+        self.detector_origin = detector_origin
+        self.axis_direction_Upx = U
+        self.axis_direction_Vpx = V
+        # plus some useful extras
+        self.image_plane = image_plane
+        self.principal_point_3d = principal_point_3d
+        self.source_detector_distance = source_detector_distance
+        # and a projection matrix in 3D world coordinates (3D points -> 3D points on the detector).
+        self.central_projection_3d = central_projection
+
+    def __repr__(self):
+        return "\n  ".join([
+                "SourceDetectorGeometry:",
+               f"Source Position: {self.source_position.flatten()}",
+               f"Source Detector Distance: {self.source_detector_distance}",
+               f"Detector Origin: {self.detector_origin[:,0].tolist()}",
+               f"Principal Point 3D: {self.principal_point_3d[:,0].tolist()}",
+               f"Axis Orientation:\n    U={self.axis_direction_Upx}\n    V={self.axis_direction_Vpx}"
+            ])
+
+    
+    @classmethod
+    def centralProjectionToPlane(cls, C, E):
+        """A mapping T from a 3D point C to a plane E via central projection from C.
+        Mapping is according to T*X=meet(join(C,X),E) written in matrix form."""
+        C = C.flatten()
+        E = E.flatten()
+        T = [[+ C[1]*E[1] + C[2]*E[2] + C[3]*E[3] , - C[0]*E[1]                         , - C[0]*E[2]                         , - C[0]*E[3]                         ],  # noqa
+             [- C[1]*E[0]                         , + C[0]*E[0] + C[2]*E[2] + C[3]*E[3] , - C[1]*E[2]                         , - C[1]*E[3]                         ],  # noqa
+             [- C[2]*E[0]                         , - C[2]*E[1]                         , + C[0]*E[0] + C[3]*E[3] + C[1]*E[1] , - C[2]*E[3]                         ],  # noqa
+             [- C[3]*E[0]                         , - C[3]*E[1]                         , - C[3]*E[2]                         , + C[0]*E[0] + C[1]*E[1] + C[2]*E[2] ]]  # noqa
+        return T
+
+    def detectorPixelIn3Dmm(self, u, v):
+        """ Compute the 3D location of a pixel (u, v) in world coordinates (mm) . See also: ProjectionMatrix.sourceDetectorGeometry()
+        This function mostly serves as documentation for how to interpret the source detector geometry."""
+        return self.detector_origin + self.axis_direction_Upx * u + self.axis_direction_Vpx * v 
+
+    def projectToDetector3Dmm(self, X):
+        return self.central_projection_3d @ X
+

ProjectiveGeometry23/svg_utils.py

@@ -0,0 +1,141 @@
+"""
+Interactive drawing of points, lines in 2d and 3D, as well as vidualizing X-ray source-detector geometries.
+
+Usage:
+    !pip install svg_vis
+
+    from svg.Jupyter import CanvasWithOverlay
+    from pg.homography import rotation_x, rotation_z, scale
+    from svg.Renderer import RenderSVG
+
+    target = ProjectionMatrix([...], detector_size_px, spacing)
+    
+    vis = CanvasWithOverlay(target.image_size[0], target.image_size[1])
+    
+    # World transformation
+    ax, az = 0.5, 0.5
+    s = 0.2
+    
+    def handle_draw(vis):
+        global ax
+        global az
+        x,y = vis.mouse_state.pos()
+        if vis.mouse_state.clicked:
+            az += vis.mouse_state.dx * 0.01
+            ax += vis.mouse_state.dy * 0.01
+
+        svg = RenderSVG((vis.w, vis.h))
+    
+        svg.add(svg_world_geometry)
+        svg.add(svg_source_detector, projection=target,
+                draw_on_detector=svg_world_geometry,
+                label_source='C0', label_detector='I0(u,v)')
+                
+        T = scale(s) @ rotation_x(ax) @ rotation_z(az)
+        raw_svg_code = svg.render(P=target.P@T)
+        vis.html_overlay.value = raw_svg_code
+
+    vis.handle_draw = handle_draw
+    
+    vis.display()
+
+Author: André Aichert
+Date: Dec 11th, 2023
+"""
+
+
+from svg_snip.Composer import Composer
+import svg_snip.Elements as e2d
+import svg_snip.Elements3D as e3d
+
+import ProjectiveGeometry23.utils as pgu
+from ProjectiveGeometry23 import pluecker
+
+from ProjectiveGeometry23.central_projection import ProjectionMatrix
+from ProjectiveGeometry23.source_detector_geometry import SourceDetectorGeometry
+
+
+def svg_coordinate_frame(P, size=100, **kwargs):
+    """Draw a coordinate system of default size 100."""
+    el = [
+        '<g>',
+        # Coordinate frame
+        e3d.line(P=P, X1=[0,0,0,1], X2=[size,0,0,1], stroke='red', **kwargs),
+        e3d.line(P=P, X1=[0,0,0,1], X2=[0,size,0,1], stroke='green', **kwargs),
+        e3d.line(P=P, X1=[0,0,0,1], X2=[0,0,size,1], stroke='blue', **kwargs)
+    ]
+    return '\n  '.join(el) + '\n</g>\n'
+
+
+def svg_world_geometry(P, **kwargs):
+    """Draw a coordinate system of size 100 and a wire cube
+    of the same size centered in the origin."""
+    el = [
+        '<g>',
+        # Coordinate frame
+        e3d.line(P=P, X1=[0,0,0,1], X2=[100,0,0,1], stroke='red', **kwargs),
+        e3d.line(P=P, X1=[0,0,0,1], X2=[0,100,0,1], stroke='green', **kwargs),
+        e3d.line(P=P, X1=[0,0,0,1], X2=[0,0,100,1], stroke='blue', **kwargs),
+        # a cube with size 100
+        e3d.wire_cube(P=P, min=[-50,-50,-50], max=[50,50,50], stroke='black', **kwargs)
+    ]
+    return '\n  '.join(el) + '\n</g>\n'
+
+
+def svg_source_detector(P, projection: ProjectionMatrix, draw_on_detector=None, **kwargs):
+    """Draw X-ray source-detector geometry. 
+    Define draw_on_detector as any SVG drawing function to project
+    additional 3D geometry to the detector plane."""
+    sdg = SourceDetectorGeometry(projection)
+    C = pgu.cvec(sdg.source_position)
+    O = sdg.detector_origin
+    U = pgu.cvec(sdg.axis_direction_Upx) * projection.image_size[0]
+    V = pgu.cvec(sdg.axis_direction_Vpx) * projection.image_size[1]
+
+    el = [
+        '<g>\n',
+        # Source position
+        e3d.point(P=P, X=C, r=1, fill="black", **kwargs),
+        # Detector frame
+        e3d.polygon(P=P, Xs=[O, O+U, O+V+U ,O+V],
+                    fill="#00000020", stroke="#00000040", **kwargs),
+        e3d.line(P=P, X1=O, X2=O + U, stroke="magenta", **kwargs),
+        e3d.line(P=P, X1=O, X2=O + V, stroke="cyan", **kwargs),
+        # Frustum
+        e3d.line(P=P, X1=C, X2=O, stroke="#00000020", **kwargs),
+        e3d.line(P=P, X1=C, X2=O+V, stroke="#00000020", **kwargs),
+        e3d.line(P=P, X1=C, X2=O+U, stroke="#00000020", **kwargs),
+        e3d.line(P=P, X1=C, X2=O+V+U, stroke="#00000020", **kwargs)
+    ]
+
+    if 'label_source' in kwargs:
+        el += [e3d.text(P=P, X=C, content=kwargs['label_source'], **kwargs)]
+    if 'label_detector' in kwargs:
+        el += [e3d.text(P=P, X=O, content=kwargs['label_detector'], **kwargs)]
+
+    if draw_on_detector is not None:
+        T_detector = sdg.central_projection_3d
+        detector = draw_on_detector(P=P@T_detector, **kwargs)
+    else:
+        detector = ""
+    
+    return '\n<!-->Source Detector Geometry<-->\n' + detector + '\n  '.join(el) + '\n</g>\n'
+
+
+def svg_homogeneous_line(l, composer: Composer, stroke="yellow", **kwargs):
+    """Draw a 2D line given in homogeneous coordinates.
+        Note: composer is passed in automatically via svg.Renderer.
+    """
+    w, h = composer.image_size
+    l = pgu.cvec(l)
+    x1, y1, x2, y2 = pgu.intersectLineWithRect(l, w, h)
+    if not all(isinstance(v, float) for v in [x1, y1, x2, y2]):
+        return ""
+    return e2d.line(x1=x1, y1=y1, x2=x2, y2=y2, composer=composer, stroke=stroke, **kwargs)
+
+
+def svg_pluecker_line(P, L, **kwargs):
+    """Draw a 3D line given in plucker coordinates."""
+    l = pluecker.project(L, P)
+    return svg_homogeneous_line(l, **kwargs)
+    

ProjectiveGeometry23/utils.py

@@ -0,0 +1,238 @@
+"""
+Utility functions for geometry.
+
+Note that these functions are imported directly to projective_geometry.
+
+Example (compute line through point [2, 1] pointing right):
+    import projective_geometry as pg
+    pg.join(RP2Point(1, 2, 1), RP2Point(0, 1, 0))
+
+Author: André Aichert
+Date: June 22, 2023
+
+FIXME (?) numpy is awkward with keeping track of row versus column vectors.
+          Possibly simplify code to just use 1D arrays?
+
+"""
+
+import numpy as np
+from numpy.linalg import pinv
+import shlex
+
+
+def dot(a,b):
+    """Computes dot product for two vectors, no matter the actual shape of the
+    numpy array (e.g. 2D row or 2D column or 1D) """
+    return np.dot(a.ravel(), b.ravel())
+
+
+def cvec(vector):
+    """Column vector from 1D array or list of values."""
+    vector = np.array(vector)
+    if vector.ndim == 1:
+        vector = vector.reshape(-1, 1)
+    return vector
+
+
+def nullspace(M):
+    """ Solve M@X == 0 for |X| == 1.
+    Returns solution closest to 0 if M is full rank"""
+    _, _, V = np.linalg.svd(M)
+    return V[-1, :]
+
+
+def append(vector, last_coordinate):
+    """"Takes a vector as a list of values or an np.array, interprets it as a
+    column vector and appends the value last_coordinate to the end of it."""
+    vector = cvec(vector)
+    return np.vstack([vector, [last_coordinate]])
+
+
+def homogenize(euclidean):
+    """"Takes a vector as a list of values or an np.array, interprets it as a
+    column vector and appends a one to the end of it."""
+    return append(euclidean, 1.0)
+
+
+def infinite(direction):
+    """"Takes a vector as a list of values or an np.array, interprets it as a
+    column vector and appends a zero to the end of it. Normalized to unit."""
+    return append(direction, 0.0) / np.linalg.norm(direction)
+
+
+def dehomogenize(vector):
+    """"Divides column vector by last element and returns all but last element.
+    """
+    vector = cvec(vector)
+    return vector[0:-1] / vector[-1]
+
+
+def hessianNormalForm(vector):
+    """Compute the Hessian normal form of a 2D line or 3D plane given as
+    homogeneous three-, respectively four-vector."""
+    return vector / np.linalg.norm(vector[0:-1])
+
+
+def RP2Point(x, y, w=1):
+    """Functions to improve code readability"""
+    return cvec([x,y,w])
+
+
+def RP2Line(l0, l1, l2):
+    """Functions to improve code readability"""
+    return cvec([l0, l1, l2])
+
+
+def RP3Point(x, y, z, w=1):
+    """Functions to improve code readability"""
+    return cvec([x,y,z,w])
+
+
+def RP3Plane(p0, p1, p2, p3):
+    """Functions to improve code readability"""
+    return cvec([p0, p1, p2, p3])
+
+
+def join2(a,b):
+    """Compute joining line from two homogeneous 2D points."""
+    return cvec(np.cross(cvec(a)[:,0], cvec(b)[:,0])) 
+
+
+def meet2(l,m):
+    """Compute intersection from homogeneous coordinates of two 2D lines."""
+    return cvec(np.cross(cvec(l)[:,0], cvec(m)[:,0]))
+
+
+def join3(A, B, C):
+    """
+    Compute the common plane passing through three points or the point of
+    intersection of three planes.
+
+    Note: for computing the joining line from two 3D points, please use
+          L = pluecker.join_points(A,B)
+
+    Parameters:
+        A, B, C: 1D arrays or column vectors representing three points
+                 in homogeneous coordinates.
+    """
+    ABC = np.vstack((A, B, C)) if A.ndim == 1 else np.hstack((A, B, C))
+    P = np.array([
+        +np.linalg.det(ABC[[1, 2, 3], :]),
+        -np.linalg.det(ABC[[0, 2, 3], :]),
+        +np.linalg.det(ABC[[0, 1, 3], :]),
+        -np.linalg.det(ABC[[0, 1, 2], :]),
+    ])
+    return cvec(P)
+
+
+def meet3(P, Q, R):
+    """
+    Compute the point of intersection for three planes that meet at one point.
+    
+    Note: for computing the line of intersection from two 3D planes, please use
+          L = pluecker.meet_planes(P,Q)
+
+    Parameters:
+        P, Q, R: 1D arrays or column vectors representing planes in homogeneous
+                 coordinates.
+    """
+    PQR = np.vstack((P, Q, R)) if P.ndim == 1 else np.hstack((P, Q, R))
+    X = np.array([
+        +np.linalg.det(PQR[[1, 2, 3], :]),
+        -np.linalg.det(PQR[[0, 2, 3], :]),
+        +np.linalg.det(PQR[[0, 1, 3], :]),
+        -np.linalg.det(PQR[[0, 1, 2], :]),
+    ])
+    return cvec(X)
+    
+    
+def KRt(K, R, t):
+    """Compose projection matrix from intrinsic and extrinsic parameters."""
+    return K@np.column_stack((R,t))
+
+
+def line2d_to_angle_intercept(l):
+    """Convert homogeneous coordinates of a 2D line to ange and intercept.
+    As is the convention in mathematics, the angle is measured with respect
+    to the x-axis. alpha=t=0 corresponds to the line (0,1,0,0)."""
+    alpha = np.arctan2(l[1], l[0]) - np.pi * 0.5  # angle
+    alpha = alpha + 2.0 * np.pi if alpha < -np.pi else alpha
+    t = -l[2] / np.sqrt(l[0] * l[0] + l[1] * l[1])  # intercept
+    return np.array([alpha, t])
+
+
+def line2d_from_angle_intercept(alpha, t):
+    """Convert ange and intercept to homogeneous coordinates of a 2D line.
+    As is the convention in mathematics, the angle is measured with respect
+    to the x-axis. alpha=t=0 corresponds to the line (0,1,0,0)."""
+    return RP2Line(
+       np.cos(alpha + np.pi * 0.5),
+       np.sin(alpha + np.pi * 0.5),
+       -t)
+
+
+def intersectLineWithRect(l, n_x: float, n_y: float ):
+    """Intersects line with a rect. Use this for drawing lines.
+    Arguments:
+        l              a 2D line in homogeneous coordinates.
+                       sequence of numbers or np.array.
+    Returns:
+        x1 y1 x2 y2    line entry (x1,y1) and exit points (x2,y2)."""
+
+    eps = 1e-10
+    l = cvec(l)
+    # Find intersections with image boundaries
+    intersection = [
+        meet2(l,cvec([1,0,0]))[:,0],
+        meet2(l,cvec([-1,0,n_x-1]))[:,0],
+        meet2(l,cvec([0,1,0]))[:,0],
+        meet2(l,cvec([0,-1,n_y-1]))[:,0]
+    ]
+
+    # Find intersections which are in bounds
+    pto, pfrom = [-1,-1,-1], [-1,-1,-1]
+    for i in range(4):
+        if abs(intersection[i][2])>eps:
+            intersection[i] = intersection[i] / intersection[i][2]        
+        if  intersection[i][0]<=n_x+eps and intersection[i][1]<=n_y+eps and \
+            intersection[i][0]+eps>=0 and intersection[i][1]+eps>=0:
+            if pfrom[0]<0:
+                pfrom = [intersection[i][0],intersection[i][1],0]
+            elif pto[0]<0:
+                pto = [intersection[i][0],intersection[i][1],0]
+            else:
+                # This may happen if a corner coincides with the line.
+                # Then, we have to use two intersections, which are far apart to get the line.
+                pto2=cvec([intersection[i][0],intersection[i][1],0])
+                if np.linalg.norm(np.array(pfrom)-np.array(pto)) < np.linalg.norm(np.array(pfrom)-np.array(pto2)):
+                    pto=pto2
+ 
+    return (pfrom[0],pfrom[1],pto[0],pto[1])
+
+
+def parse_ompl(ompl):
+    """Load a text file with one matrix per line (*.ompl).
+    Lines that so not start with '#' character (for comments) contain a colon
+    seperated list of floating point values, each representing a matrix row.
+    Lines starting with '#>' may contain additional meta info, such as
+    #> spacing="0.1" detector_size_px="800 600"
+    """
+    comments = []
+    meta = dict()
+    matrices = []
+    for index, line in enumerate(ompl.split('\n')):
+        if line.startswith('#'):
+            if line.startswith('#>'):
+                # Expected string: key1:"value1" key2:"value2" ...
+                kvps = [assignment.split('=') for assignment in shlex.split(line[2:])]
+                meta.update({kvp[0]: kvp[1] for kvp in kvps})
+            else:
+                comments += (index, line[2:])
+        else:
+            if len(line) < 2:
+                continue
+            line = line.replace('[', '')
+            line = line.replace(']', '')
+            matrices += [[[float(value) for value in row.split()] for row in line.split(';')]]
+    return matrices, meta, comments
+

projectivegeometry23-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: ProjectiveGeometry23
+Version: 0.1.0
+Summary: Projective geometry in 2D and 3D with homogeneous and Plücker coordinates, projection matrices, and visualization.
+Home-page: https://github.com/aaichert/ProjectiveGeometry23
+Author: Andre Aichert
+Author-email: aaichert@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: svg
+Requires-Dist: svg_snip; extra == "svg"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# ProjectiveGeometry23
+## Projective Geometry of Two- and Three-space
+
+`ProjectiveGeometry23` is a collection of numpy-based utilities for projective geometry of real two- and three-space, including homogeneous coordinates of point, lines and planes, Plücker coordinates and projection matrices.
+
+The package has been converted from an existing C++ implementation [LibProjectiveGeometry](https://github.com/aaichert/LibProjectiveGeometry), which is well-tested and obviously faster.
+
+The main use of this code is for the visualization or X-Ray source-detector geometries but applied generally to geometric computer vision problems. 
+
+Features:
+ - Computing with points, lines and planes
+ - Plücker coordinates, Plücker matrices
+ - Projection matrices, intrinsic and extrinsic parameters
+ - Decomposition of projection matrices, backprojection
+ - Visualization of X-Ray source-detector geometries
+ - (WIP) estimation based on direct linear transform, X-ray calibraion
+
+General recommendation for better readibility of outputs:
+
+```py
+from rich import print
+np.set_printoptions(suppress=True)
+```
+
+Example of an interactive visualization, using the optional `svg_snip` package:
+
+```py
+from svg_snip.Jupyter import CanvasWithOverlay
+from svg_snip.Composer import Composer
+import svg_snip.Elements as e2d
+import svg_snip.Elements3D as e3d
+
+from ProjectiveGeometry23.homography import rotation_x, rotation_z, scale
+from ProjectiveGeometry23.svg_utils import svg_source_detector, svg_world_geometry
+    
+vis = CanvasWithOverlay(int(target.image_size[0]), int(target.image_size[1]))
+
+# World transformation
+ax, az = 0.5, 0.5
+s = 0.2
+
+def handle_draw(vis):
+    global ax
+    global az
+    x,y = vis.mouse_state.pos()
+    svg = Composer((vis.w, vis.h))
+
+    svg.add(svg_world_geometry)
+    svg.add(svg_source_detector, projection=target,
+            draw_on_detector=svg_world_geometry,
+            label_source='C0', label_detector='I0(u,v)')
+
+    svg.add(e2d.star, x=x, y=y, size=8,
+        fill="red" if vis.mouse_state.clicked else "blue")
+
+    svg.add(e2d.text, x=10, y=20, content=f'ax={ax:.3} az={az:.3}')
+            
+    T = scale(s) @ rotation_x(ax) @ rotation_z(az)
+    raw_svg_code = svg.render(P=target.P@T)
+    vis.html_overlay.value = raw_svg_code
+    
+    if vis.mouse_state.clicked:
+        az += vis.mouse_state.dx * 0.01
+        ax += vis.mouse_state.dy * 0.01
+    
+vis.handle_draw = handle_draw
+
+vis.display()
+
+```
+
+![source_detector_geometry.png](source_detector_geometry.png)
+
+## Installation
+
+### Using pip
+You can install `ProjectiveGeometry23` using pip:
+
+```bash
+pip install ProjectiveGeometry23
+```
+
+
+### Using `setup.py`
+
+```sh
+git clone https://github.com/aaichert/ProjectiveGeometry23
+cd ProjectiveGeometry23
+python setup.py install
+```
+
+### Testing and Publication on PyPy
+
+Two useful code snippets
+
+```bash
+python -m unittest discover tests
+```
+
+```bash
+python setup.py sdist bdist_wheel
+pip install twine
+twine upload dist/*
+```
+
+### References
+
+1. LibProjectiveGeometry (c++). GitHub https://github.com/aaichert/EpipolarConsistency/tree/master/code/LibProjectiveGeometry
+2. Hartley, Richard, and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003. https://www.robots.ox.ac.uk/~vgg/hzbook/
+3. Coxeter, Harold Scott Macdonald. Projective geometry. Springer Science & Business Media, 2003.
+4. Stolfi, Jorge. "Oriented projective geometry." Proceedings of the third annual symposium on Computational geometry. 1987.

projectivegeometry23-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+ProjectiveGeometry23/__init__.py,sha256=nEYkor_6Nf-o7BiMinE-QURrXcIQtJbsyd613uX6Pfs,57
+ProjectiveGeometry23/central_projection.py,sha256=yh12BpCTF9SK2bUH14lP4zWhbr-G_luCOcVY10SGC5M,9718
+ProjectiveGeometry23/estimation.py,sha256=3-xccEYAG4J9ojlxeHx2rEBfFKIwcFhMsqaCmi-D5mw,2286
+ProjectiveGeometry23/homography.py,sha256=P0B96CaeOccoWRDHHShFLsIea0wSdkn-1XHvLmtisEs,2896
+ProjectiveGeometry23/pluecker.py,sha256=ayanNyDbwxwCGdC2bEXAGq3kjTQRXTtgticK7s9zABY,6586
+ProjectiveGeometry23/source_detector_geometry.py,sha256=MBE45j9uVqk8rW-PPABKNJRT_QthfZX2yuvcz6_zIxg,5130
+ProjectiveGeometry23/svg_utils.py,sha256=-spwByvZKlSoTnH1cX5VpZ8AhI0jAVHB8Mg1HUm5GD0,4988
+ProjectiveGeometry23/utils.py,sha256=p6ZowiTDr0yvo_TTCF8mxtt3e-dFoEDw53pLYJ__hiY,8108
+projectivegeometry23-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+projectivegeometry23-0.1.0.dist-info/METADATA,sha256=KvhGzS8uoNT_Qez2Xxz9rCOiHUu2kqJHDdyvKNTvDBM,4394
+projectivegeometry23-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+projectivegeometry23-0.1.0.dist-info/top_level.txt,sha256=WwClYIS9b_oVIm0Xkr6hB-A8-W8UgFOLW3yQQM1mx2g,21
+projectivegeometry23-0.1.0.dist-info/RECORD,,

projectivegeometry23-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+