chore(spinbox): fix return type

Author: ceccopierangiolieugenio

libs/pyTermTk/TermTk/TTkWidgets/spinbox.py

@@ -168,7 +168,7 @@ def mouseDragEvent(self, evt:TTkMouseEvent) -> bool:
         d = evt.y-evt.x
         if self._draggable:
             self.setValue(self._valueDelta + self._mouseDelta - d)
-            return True
+        return True
 
     def setEnabled(self, enabled=True):
         self._lineEdit.setEnabled(enabled)

tools/image/example.pillow.deformation.01.py

@@ -0,0 +1,79 @@
+from PIL import Image, ImageDraw
+import numpy as np
+
+def find_coeffs(source_coords, target_coords):
+    """
+    Calculate coefficients for perspective transformation.
+    """
+    matrix = []
+    for s, t in zip(source_coords, target_coords):
+        matrix.extend([
+            [s[0], s[1], 1, 0, 0, 0, -t[0] * s[0], -t[0] * s[1]],
+            [0, 0, 0, s[0], s[1], 1, -t[1] * s[0], -t[1] * s[1]]
+        ])
+
+    A = np.matrix(matrix, dtype=np.float64)
+    B = np.array(target_coords).reshape(8)
+
+    try:
+        res = np.linalg.solve(A, B)
+        return tuple(np.array(res).flatten())
+    except np.linalg.LinAlgError:
+        print("Error: Could not solve transformation matrix.")
+        return None
+
+def main():
+    # Load the input image
+    try:
+        image = Image.open("img4.png").convert("RGBA")
+    except FileNotFoundError:
+        print("Error: img1.png not found")
+        return
+
+    # Create an empty output image (transparent background)
+    output_size = (800, 600)
+    output_image = Image.new("RGBA", output_size, (0, 0, 0, 0))
+
+    # Define the target quadrilateral (very small area in the output image)
+    target_quad = [(50, 50), (100, 60), (120, 100), (45, 90)]
+
+    # Define the source coordinates (entire input image)
+    width, height = image.size
+    source_quad = [(0, 0), (width, 0), (width, height), (0, height)]
+
+    # Calculate the transformation coefficients
+    coeffs = find_coeffs(source_quad, target_quad)
+    if not coeffs:
+        return
+
+    # Calculate the bounding box of the target quadrilateral
+    min_x = min(p[0] for p in target_quad)
+    min_y = min(p[1] for p in target_quad)
+    max_x = max(p[0] for p in target_quad)
+    max_y = max(p[1] for p in target_quad)
+
+    # Create a polygon mask to ensure transparency outside the target area
+    mask = Image.new("L", output_size, 0)
+    draw = ImageDraw.Draw(mask)
+    draw.polygon(target_quad, fill=255)
+
+    # Apply the transformation to the entire input image
+    transformed = image.transform(
+        output_size,
+        Image.PERSPECTIVE,
+        coeffs,
+        Image.BILINEAR
+    )
+
+    # Apply the mask to keep only the transformed area within the target quadrilateral
+    transformed.putalpha(mask)
+
+    # Paste the transformed image onto the output image
+    output_image.paste(transformed, (0, 0), transformed)
+
+    # Save the result
+    output_image.save("outImage.png")
+    print("Image transformed and saved as outImage.png")
+
+if __name__ == "__main__":
+    main()

tools/image/example.pillow.deformation.02.py

@@ -0,0 +1,8 @@
+from PIL import Image
+
+img = Image.open('img5.png')
+
+w,h = img.size
+out = img.transform((800,600), Image.Transform.QUAD, [100, 100, 500, 600, 400, 700, 50])
+
+out.show()

tools/image/example.projection.2.py

@@ -0,0 +1,70 @@
+import math
+
+def project_3d_to_2d(square_3d, observer, look_at, fov=90, aspect_ratio=1, near=0.1, far=1000):
+    """
+    Project a 3D square onto a 2D plane.
+
+    Args:
+        square_3d: List of 4 points representing the square in 3D space [(x, y, z), ...].
+        observer: The observer's position in 3D space (x, y, z).
+        look_at: The point the observer is looking at in 3D space (x, y, z).
+        fov: Field of view in degrees.
+        aspect_ratio: Aspect ratio of the 2D plane (width/height).
+        near: Near clipping plane.
+        far: Far clipping plane.
+
+    Returns:
+        List of 2D points [(x, y), ...].
+    """
+    # Step 1: Create the view matrix
+    def normalize(v):
+        return v / np.linalg.norm(v)
+
+    forward = normalize(np.array(look_at) - np.array(observer))
+    right = normalize(np.cross(forward, [0, 1, 0]))
+    up = np.cross(right, forward)
+
+    view_matrix = np.array([
+        [right[0], right[1], right[2], -np.dot(right, observer)],
+        [up[0], up[1], up[2], -np.dot(up, observer)],
+        [-forward[0], -forward[1], -forward[2], np.dot(forward, observer)],
+        [0, 0, 0, 1]
+    ])
+
+    # Step 2: Create the projection matrix
+    fov_rad = np.radians(fov)
+    f = 1 / np.tan(fov_rad / 2)
+    projection_matrix = np.array([
+        [f / aspect_ratio, 0, 0, 0],
+        [0, f, 0, 0],
+        [0, 0, (far + near) / (near - far), (2 * far * near) / (near - far)],
+        [0, 0, -1, 0]
+    ])
+
+    # Step 3: Transform the 3D points to 2D
+    square_2d = []
+    for point in square_3d:
+        # Convert to homogeneous coordinates
+        point_3d = np.array([point[0], point[1], point[2], 1])
+        # Apply view and projection transformations
+        transformed_point = projection_matrix @ view_matrix @ point_3d
+        # Perform perspective divide
+        x = transformed_point[0] / transformed_point[3]
+        y = transformed_point[1] / transformed_point[3]
+        square_2d.append((x, y))
+
+    return square_2d
+
+
+# Example usage
+square_3d = [
+    (1, 1, 5),  # Top-right
+    (-1, 1, 5),  # Top-left
+    (-1, -1, 5),  # Bottom-left
+    (1, -1, 5)  # Bottom-right
+]
+observer = (0, 0, 0)  # Observer's position
+look_at = (0, 0, 1)  # Observer is looking along the positive Z-axis
+
+square_2d = project_3d_to_2d(square_3d, observer, look_at)
+print("2D Coordinates of the square:", square_2d)

tools/image/example.projection.3.py

@@ -0,0 +1,74 @@
+import math
+
+def project_3d_to_2d(observer, look_at, fov_h, fov_v, screen_width, screen_height, point_3d):
+    """
+    Project a 3D point onto a 2D screen.
+
+    Args:
+        observer: The observer's position in 3D space (x, y, z).
+        look_at: The point the observer is looking at in 3D space (x, y, z).
+        fov_h: Horizontal field of view in radians.
+        fov_v: Vertical field of view in radians.
+        screen_width: Width of the 2D screen.
+        screen_height: Height of the 2D screen.
+        point_3d: The 3D point to project (x, y, z).
+
+    Returns:
+        The 2D coordinates of the projected point (x, y) on the screen.
+    """
+    # Step 1: Calculate the forward, right, and up vectors
+    def normalize(v):
+        length = math.sqrt(sum(coord ** 2 for coord in v))
+        return tuple(coord / length for coord in v)
+
+    forward = normalize((look_at[0] - observer[0], look_at[1] - observer[1], look_at[2] - observer[2]))
+    right = normalize((
+        forward[1] * 0 - forward[2] * 1,
+        forward[2] * 0 - forward[0] * 0,
+        forward[0] * 1 - forward[1] * 0
+    ))
+    up = (
+        right[1] * forward[2] - right[2] * forward[1],
+        right[2] * forward[0] - right[0] * forward[2],
+        right[0] * forward[1] - right[1] * forward[0]
+    )
+
+    # Step 2: Transform the 3D point into the observer's coordinate system
+    relative_point = (
+        point_3d[0] - observer[0],
+        point_3d[1] - observer[1],
+        point_3d[2] - observer[2]
+    )
+    x_in_view = sum(relative_point[i] * right[i] for i in range(3))
+    y_in_view = sum(relative_point[i] * up[i] for i in range(3))
+    z_in_view = sum(relative_point[i] * forward[i] for i in range(3))
+
+    # Step 3: Perform perspective projection
+    if z_in_view <= 0:
+        raise ValueError("The point is behind the observer and cannot be projected.")
+
+    aspect_ratio = screen_width / screen_height
+    tan_fov_h = math.tan(fov_h / 2)
+    tan_fov_v = math.tan(fov_v / 2)
+
+    ndc_x = x_in_view / (z_in_view * tan_fov_h * aspect_ratio)
+    ndc_y = y_in_view / (z_in_view * tan_fov_v)
+
+    # Step 4: Map normalized device coordinates (NDC) to screen coordinates
+    screen_x = (ndc_x + 1) / 2 * screen_width
+    screen_y = (1 - ndc_y) / 2 * screen_height
+
+    return screen_x, screen_y
+
+
+# Example usage
+observer = (0, 0, 0)  # Observer's position
+look_at = (0, 0, 1)  # Observer is looking along the positive Z-axis
+fov_h = math.radians(90)  # Horizontal FOV in radians
+fov_v = math.radians(60)  # Vertical FOV in radians
+screen_width = 800  # Screen width
+screen_height = 600  # Screen height
+point_3d = (1, 1, 5)  # The 3D point to project
+
+projected_2d_point = project_3d_to_2d(observer, look_at, fov_h, fov_v, screen_width, screen_height, point_3d)
+print("Projected 2D Point:", projected_2d_point)

tools/image/example.projection.4.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+def project_point(camera_position, look_at, point_3d):
+    """
+    Project a 3D point into a normalized projection matrix.
+
+    Args:
+        camera_position: The 3D position of the camera (x, y, z).
+        look_at: The 3D position the camera is looking at (x, y, z).
+        point_3d: The 3D point to project (x, y, z).
+
+    Returns:
+        The 2D coordinates of the projected point in normalized space.
+    """
+    # Step 1: Calculate the forward, right, and up vectors
+    def normalize(v):
+        return v / np.linalg.norm(v)
+
+    forward = normalize(np.array(look_at) - np.array(camera_position))
+    right = normalize(np.cross(forward, [0, 1, 0]))
+    up = np.cross(right, forward)
+
+    # Step 2: Create the view matrix
+    view_matrix = np.array([
+        [right[0], right[1], right[2], -np.dot(right, camera_position)],
+        [up[0], up[1], up[2], -np.dot(up, camera_position)],
+        [-forward[0], -forward[1], -forward[2], np.dot(forward, camera_position)],
+        [0, 0, 0, 1]
+    ])
+
+    # Step 3: Create the projection matrix
+    near = 1.0  # Near plane normalized to 1
+    width = 1.0  # Width of the near plane
+    height = 1.0  # Height of the near plane
+    aspect_ratio = width / height
+
+    projection_matrix = np.array([
+        [1 / aspect_ratio, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, -1, -2 * near],
+        [0, 0, -1, 0]
+    ])
+
+    # Step 4: Transform the 3D point into clip space
+    point_3d_homogeneous = np.array([point_3d[0], point_3d[1], point_3d[2], 1])
+    view_space_point = view_matrix @ point_3d_homogeneous
+    clip_space_point = projection_matrix @ view_space_point
+
+    # Step 5: Perform perspective divide to get normalized device coordinates (NDC)
+    if clip_space_point[3] == 0:
+        raise ValueError("Invalid projection: w component is zero.")
+    ndc_x = clip_space_point[0] / clip_space_point[3]
+    ndc_y = clip_space_point[1] / clip_space_point[3]
+
+    return ndc_x, ndc_y
+
+
+# Example usage
+camera_position = (0, 0, 0)  # Camera position
+look_at = (0, 0, -1)  # Camera is looking along the negative Z-axis
+point_3d = (0.5, 0.5, -2)  # A 3D point to project
+
+projected_point = project_point(camera_position, look_at, point_3d)
+print("Projected 2D Point in NDC:", projected_point)

tools/image/example.projection.py

@@ -0,0 +1,70 @@
+import numpy as np
+
+def project_3d_to_2d(square_3d, observer, look_at, fov=90, aspect_ratio=1, near=0.1, far=1000):
+    """
+    Project a 3D square onto a 2D plane.
+
+    Args:
+        square_3d: List of 4 points representing the square in 3D space [(x, y, z), ...].
+        observer: The observer's position in 3D space (x, y, z).
+        look_at: The point the observer is looking at in 3D space (x, y, z).
+        fov: Field of view in degrees.
+        aspect_ratio: Aspect ratio of the 2D plane (width/height).
+        near: Near clipping plane.
+        far: Far clipping plane.
+
+    Returns:
+        List of 2D points [(x, y), ...].
+    """
+    # Step 1: Create the view matrix
+    def normalize(v):
+        return v / np.linalg.norm(v)
+
+    forward = normalize(np.array(look_at) - np.array(observer))
+    right = normalize(np.cross(forward, [0, 1, 0]))
+    up = np.cross(right, forward)
+
+    view_matrix = np.array([
+        [right[0], right[1], right[2], -np.dot(right, observer)],
+        [up[0], up[1], up[2], -np.dot(up, observer)],
+        [-forward[0], -forward[1], -forward[2], np.dot(forward, observer)],
+        [0, 0, 0, 1]
+    ])
+
+    # Step 2: Create the projection matrix
+    fov_rad = np.radians(fov)
+    f = 1 / np.tan(fov_rad / 2)
+    projection_matrix = np.array([
+        [f / aspect_ratio, 0, 0, 0],
+        [0, f, 0, 0],
+        [0, 0, (far + near) / (near - far), (2 * far * near) / (near - far)],
+        [0, 0, -1, 0]
+    ])
+
+    # Step 3: Transform the 3D points to 2D
+    square_2d = []
+    for point in square_3d:
+        # Convert to homogeneous coordinates
+        point_3d = np.array([point[0], point[1], point[2], 1])
+        # Apply view and projection transformations
+        transformed_point = projection_matrix @ view_matrix @ point_3d
+        # Perform perspective divide
+        x = transformed_point[0] / transformed_point[3]
+        y = transformed_point[1] / transformed_point[3]
+        square_2d.append((x, y))
+
+    return square_2d
+
+
+# Example usage
+square_3d = [
+    (1, 1, 5),  # Top-right
+    (-1, 1, 5),  # Top-left
+    (-1, -1, 5),  # Bottom-left
+    (1, -1, 5)  # Bottom-right
+]
+observer = (0, 0, 0)  # Observer's position
+look_at = (0, 0, 1)  # Observer is looking along the positive Z-axis
+
+square_2d = project_3d_to_2d(square_3d, observer, look_at)
+print("2D Coordinates of the square:", square_2d)