c4dynamics 2.0.3__py3-none-any.whl

c4dynamics/utils/tictoc.py

@@ -0,0 +1,167 @@
+import sys 
+sys.path.append('.')
+import time
+_tic = 0.0
+
+def tic():
+    '''
+    Starts stopwatch timer.
+
+    Inspired by `MATLAB's` tic toc, `tic()` records the current time to start measuring elapsed time.
+    When used in conjunction with `toc()` serves as a stopwatch 
+    timer to measure the time interval between two events. 
+
+    Returns
+    -------
+    out : float
+        The recorded start time. 
+
+    Examples 
+    --------
+
+    .. code::
+
+      >>> import c4dynamics as c4d 
+      >>> import numpy as np 
+
+
+    .. code:: 
+        
+      >>> N = 10000
+      >>> tic()   # doctest: +IGNORE_OUTPUT
+      >>> a = np.ones((1, 3))
+      >>> for i in range(N - 1):
+      ...     a = np.concatenate((a, np.ones((1, 3))))
+      >>> t1 = toc() # doctest: +IGNORE_OUTPUT
+      >>> c4d.cprint('numpy concat: ' + str(1000 * t1) + ' ms', 'r') # doctest: +IGNORE_OUTPUT
+      numpy concat: 40.0 ms
+
+    .. code:: 
+
+      >>> tic() # doctest: +IGNORE_OUTPUT
+      >>> a = np.zeros((N, 3))
+      >>> for i in range(N):
+      ...     a[i, :] = np.ones((1, 3))
+      >>> t2 = toc() # doctest: +IGNORE_OUTPUT
+      >>> c4d.cprint('numpy predefined: ' + str(1000 * t2) + ' ms', 'g') # doctest: +IGNORE_OUTPUT
+      numpy predefined: 3.0 ms
+
+    .. code:: 
+
+      >>> tic()# doctest: +IGNORE_OUTPUT
+      >>> a = []
+      >>> for i in range(N):
+      ...     a.append([1, 1, 1])
+      >>> a = np.array(a)
+      >>> t3 = toc()# doctest: +IGNORE_OUTPUT
+      >>> c4d.cprint('list to numpy: ' + str(1000 * t3) + ' ms', 'y') # doctest: +IGNORE_OUTPUT
+      list to numpy: 0.0 ms
+    
+    '''
+
+    global _tic
+    _tic = time.time()
+    return _tic
+
+def toc(show = True):
+  '''
+
+  Stops the stopwatch timer and reads the elapsed time.
+
+  Measures the elapsed time since the last call to `tic()` and prints the result in seconds.
+
+
+  Returns
+  -------
+  out : float
+      Elapsed time in seconds.
+
+  Examples 
+  --------
+
+  .. code::
+
+    >>> import c4dynamics as c4d 
+    >>> import numpy as np 
+
+
+  .. code:: 
+      
+    >>> N = 10000
+    >>> tic() # doctest: +IGNORE_OUTPUT
+    >>> a = np.ones((1, 3))
+    >>> for i in range(N - 1):
+    ...     a = np.concatenate((a, np.ones((1, 3))))
+    >>> t1 = toc() # doctest: +IGNORE_OUTPUT
+    >>> c4d.cprint('numpy concat: ' + str(1000 * t1) + ' ms', 'r') # doctest: +IGNORE_OUTPUT
+    numpy concat: 31.0 ms
+
+  .. code:: 
+
+    >>> tic() # doctest: +IGNORE_OUTPUT
+    >>> a = np.zeros((N, 3))
+    >>> for i in range(N):
+    ...     a[i, :] = np.ones((1, 3))
+    >>> t2 = toc() # doctest: +IGNORE_OUTPUT
+    >>> c4d.cprint('numpy predefined: ' + str(1000 * t2) + ' ms', 'g') # doctest: +IGNORE_OUTPUT
+    numpy predefined: 15.0 ms
+
+  .. code:: 
+
+    >>> tic() # doctest: +IGNORE_OUTPUT
+    >>> a = []
+    >>> for i in range(N):
+    ...     a.append([1, 1, 1])
+    >>> a = np.array(a)
+    >>> t3 = toc() # doctest: +IGNORE_OUTPUT
+    >>> c4d.cprint('list to numpy: ' + str(1000 * t3) + ' ms', 'y') # doctest: +IGNORE_OUTPUT
+    list to numpy: 0.0 ms
+
+    
+  '''
+
+  global _tic
+  dt = time.time() - _tic
+  if show: print(f'{dt:.3f}')
+  return dt
+
+
+
+# tic():
+
+#     Records the current time to start measuring elapsed time.
+    
+#     Returns:
+#     float: The recorded start time.
+
+# toc():
+
+#     Measures the elapsed time since the last call to `tic()` and prints the result in seconds.
+
+#     Returns:
+#     float: The elapsed time in seconds.
+
+if __name__ == "__main__":
+
+  import doctest, contextlib, os
+  from c4dynamics import IgnoreOutputChecker, cprint
+  
+  # Register the custom OutputChecker
+  doctest.OutputChecker = IgnoreOutputChecker
+
+  tofile = False 
+  optionflags = doctest.FAIL_FAST
+
+  if tofile: 
+    with open(os.path.join('tests', '_out', 'output.txt'), 'w') as f:
+      with contextlib.redirect_stdout(f), contextlib.redirect_stderr(f):
+        result = doctest.testmod(optionflags = optionflags) 
+  else: 
+    result = doctest.testmod(optionflags = optionflags)
+
+  if result.failed == 0:
+    cprint(os.path.basename(__file__) + ": all tests passed!", 'g')
+  else:
+    print(f"{result.failed}")
+
+

c4dynamics/utils/video_gen.py

@@ -0,0 +1,300 @@
+# type: ignore 
+# # The following environment is selected: 
+# \\192.168.1.244\d\gh_repo\c4dynamics\.venv\Scripts\python.exe  
+#
+
+'''
+ working plan:
+   after proving the algo on synthetis videos i made manually here:
+   take 2 or 3 types of motion videos:
+   linear, parabole, sinsuidal
+   and show performances with c4dynamics.
+   show improvemnet for better dynamics modelling. 
+   
+'''
+import os, sys
+import socket
+import cv2
+import numpy as np
+from enum import Enum
+print(os.getcwd())
+# import c4dynamics as c4d 
+# if socket.gethostname() != 'ZivMeri-PC':
+#   os.chdir(os.path.join('\\\\192.168.1.244', 'd', 'gh_repo', 'c4dynamics'))
+print(sys.executable)
+# https://github.com/microsoft/debugpy/issues/1231
+
+FRAMEWIDTH = 1280
+FRAMEHEIGHT = 720
+
+
+
+class Im_saveshow(Enum):
+  SHOW      = 1
+  SAVE      = 2
+  SAVESHOW  = 3 
+
+class Motion_Type(Enum):
+  LINEAR    = 1
+  PARABOLE  = 2
+  SINE     = 3   
+
+def rotateimage(image, angle0, angle1):
+    # Define the angle of rotation (in degrees)
+  # angle = -90  # Change this value as needed
+
+  # dangle = pathangle - current_rotation 
+
+  # # Get the dimensions of the image
+  # height, width = image.shape[:2]
+
+  # rotation_matrix = cv2.getRotationMatrix2D((image.shape[1] / 2, image.shape[0] / 2), angle, 1)
+  # # Calculate the new dimensions of the rotated image to prevent trimming
+  # cos_theta  = np.abs(rotation_matrix[0, 0])
+  # sin_theta  = np.abs(rotation_matrix[0, 1])
+  # new_width  = int((height * sin_theta) + (width * cos_theta))
+  # new_height = int((height * cos_theta) + (width * sin_theta))
+
+  # # Adjust the rotation matrix for translation to keep the entire image visible
+  # rotation_matrix[0, 2] += (new_width / 2)  - (width / 2)
+  # rotation_matrix[1, 2] += (new_height / 2) - (height / 2)
+  # Calculate the rotation matrix
+
+  dangle = angle0 - angle1 
+
+  # Get the dimensions of the image
+  height, width = image.shape[:2]
+
+  delta_rotation_matrix = cv2.getRotationMatrix2D((width / 2, height / 2), dangle, 1)
+  angle_rotation_matrix = cv2.getRotationMatrix2D((width / 2, height / 2), dangle, 1)
+  # Calculate the new dimensions of the rotated image to prevent trimming
+  cos_theta  = np.abs(angle_rotation_matrix[0, 0])
+  sin_theta  = np.abs(angle_rotation_matrix[0, 1])
+  new_width  = int((height * sin_theta) + (width * cos_theta))
+  new_height = int((height * cos_theta) + (width * sin_theta))
+
+  # Adjust the rotation matrix for translation to keep the entire image visible
+  delta_rotation_matrix[0, 2] += (new_width / 2)  - (width / 2)
+  delta_rotation_matrix[1, 2] += (new_height / 2) - (height / 2)
+
+
+  # Perform the rotation using warpAffine
+  return cv2.warpAffine(image, delta_rotation_matrix, (new_width, new_height))
+
+  # # Display the original and rotated images (optional)
+  # cv2.imshow('Original Image', image)
+  # cv2.imshow('Rotated Image', rotated_image)
+  # cv2.waitKey(0)
+  # cv2.destroyAllWindows()
+
+  # # Save the rotated image
+  # cv2.imwrite('path_to_save_rotated_image.jpg', rotated_image)
+
+  # return rotated_image
+
+
+
+def animate(objpath, x0 = 0, y0 = 0
+              , scaling = 1, rotate = False, pathangle = None   
+                , motion = Motion_Type.LINEAR, saveshow = Im_saveshow.SAVESHOW.value):
+
+  ''' make a linear moving object video '''
+
+  # Define the dimensions of the video frame
+  saveon = any(x for x in [Im_saveshow.SAVESHOW.value, Im_saveshow.SAVE.value] if x == saveshow)
+  showon = any(x for x in [Im_saveshow.SAVESHOW.value, Im_saveshow.SHOW.value] if x == saveshow)
+
+  out = cv2.VideoWriter(os.path.join(os.getcwd(), 'examples', 'resources'
+                                          , motion.name + '_' + os.path.basename(objpath)[:-4] 
+                                            + str(int(x0)) + str(int(y0)) + '.mp4')
+                              , cv2.VideoWriter_fourcc(*'mp4v') 
+                                , 30.0, (FRAMEWIDTH, FRAMEHEIGHT))
+
+  # Load the im_object you want to move
+  im_object = cv2.imread(objpath, cv2.IMREAD_UNCHANGED)
+
+  video_duration = 1
+
+  if pathangle is None: 
+    if motion == Motion_Type.LINEAR:
+      pathangle = 0
+    elif motion == Motion_Type.PARABOLE:
+      pathangle = 45
+      video_duration = 1.5
+    elif motion == Motion_Type.SINE:
+      pathangle = 0 
+      video_duration = 2
+  
+  num_frames = int(30 * video_duration)
+  
+  # im_object = rotateimage(im_object, -pathangle * rotate)
+  im_object = cv2.resize(im_object, tuple(reversed(tuple(int(scaling * i) for i in im_object.shape[:2]))))
+  im_object = rotateimage(im_object, 0, pathangle * rotate)
+
+  im_object_height, im_object_width, _ = im_object.shape
+
+  # Ensure the im_object has 3 channels (remove alpha channel)
+  im_object = im_object[:, :, :3]
+
+  # Define initial position and velocity of the im_object
+  # change to center of image 
+  x_pos = int(x0 - im_object_width / 2) 
+  y_pos = int(y0 - im_object_height / 2)
+
+  vtotal_diag = np.sqrt(FRAMEHEIGHT**2 + FRAMEHEIGHT**2) / 30 
+  x_velocity = int(vtotal_diag * np.cos(pathangle * np.pi / 180)) # int(FRAMEWIDTH / 30)  # Adjust velocity based on frame width
+  y_velocity = int(vtotal_diag * np.sin(pathangle * np.pi / 180)) #  int(FRAMEHEIGHT / 30)  # Adjust velocity based on frame width
+  
+  # Define the duration of the video in seconds
+  
+ 
+  # Generate the frames for the video
+  for fi in range(num_frames):
+      # Create a black background frame
+      frame = np.zeros((FRAMEHEIGHT, FRAMEWIDTH, 3), dtype = np.uint8)
+
+
+      # Calculate the region to overlay the im_object on the frame
+
+      if x_pos >= 0 and x_pos + im_object_width < FRAMEWIDTH:
+        ''' simplest. all in '''
+        TO_start_col    = x_pos
+        TO_end_col      = x_pos + im_object_width
+        FROM_start_col  = 0
+        FROM_end_col    = im_object_width
+
+      elif x_pos < 0:
+        ''' pixels covered from left '''
+        TO_start_col    = 0
+        TO_end_col      = x_pos + im_object_width
+        FROM_start_col  = -x_pos
+        FROM_end_col    = im_object_width
+
+      elif x_pos + im_object_width >= FRAMEWIDTH:
+        ''' pixels covered from right '''
+        TO_start_col    = x_pos
+        TO_end_col      = FRAMEWIDTH
+        FROM_start_col  = 0
+        FROM_end_col    = max(FRAMEWIDTH - x_pos, 0)
+
+
+      if y_pos >= 0 and y_pos + im_object_height < FRAMEHEIGHT:
+        ''' simplest. all in '''
+        TO_start_row    = y_pos
+        TO_end_row      = y_pos + im_object_height
+        FROM_start_row  = 0
+        FROM_end_row    = im_object_height
+
+      elif y_pos < 0:
+        ''' pixels covered from top '''
+        TO_start_row    = 0
+        TO_end_row      = max(y_pos + im_object_height, 0)
+        FROM_start_row  = -y_pos
+        FROM_end_row    = im_object_height
+
+      elif y_pos + im_object_height >= FRAMEHEIGHT:
+        ''' pixels covered from bottom '''
+        TO_start_row    = y_pos
+        TO_end_row      = FRAMEHEIGHT
+        FROM_start_row  = 0
+        FROM_end_row    = max(FRAMEHEIGHT - y_pos, 0)
+     
+
+      fromshape = im_object[FROM_start_row : FROM_end_row, FROM_start_col : FROM_end_col].shape
+      toshape = frame[TO_start_row : TO_end_row, TO_start_col : TO_end_col].shape
+
+      frame[TO_start_row : TO_end_row, TO_start_col : TO_end_col] = (
+                   im_object[FROM_start_row : FROM_end_row, FROM_start_col : FROM_end_col]
+                      ).astype(np.uint8)
+      
+
+
+      # current_rotation = 0
+
+      if motion == Motion_Type.LINEAR: 
+        pass
+
+      elif motion == Motion_Type.PARABOLE: 
+        # parabole 
+        # f / num_frames # when this is 1/2 i want pathangle to be zero. 
+                        # when 1 to be 45.
+                        # nameyly in full circly to change by 90.
+                        # xdegrees per f.
+                        # -90deg in numframes.
+                        # x = -90 / nframe
+        pathangle -= 90 / num_frames
+        x_velocity = int(vtotal_diag * np.cos(pathangle * np.pi / 180)) # int(FRAMEWIDTH / 30)  # Adjust velocity based on frame width
+        y_velocity = int(vtotal_diag * np.sin(pathangle * np.pi / 180)) # int(FRAMEHEIGHT / 30)  # Adjust velocity based on frame width
+     
+      elif motion == Motion_Type.SINE:
+        # sinusidly 
+        # all frames: 2 * pi
+        # fi numframes
+        # path angle 0 to 360 at numframes.
+        # one frame 360/nframe
+        pathangle =  90 * np.cos(3 * fi / num_frames * 2 * np.pi)
+        x_velocity = int(vtotal_diag * np.cos(pathangle * np.pi / 180)) # int(FRAMEWIDTH / 30)  # Adjust velocity based on frame width
+        y_velocity = int(vtotal_diag * np.sin(pathangle * np.pi / 180)) #  int(FRAMEHEIGHT / 30)  # Adjust velocity based on frame width
+      
+      
+
+      # im_object = rotateimage(im_object, current_rotation, pathangle)
+      # print(f'{fi:5.0f}  {pathangle}  {x_velocity}  {y_velocity}')
+
+
+      x_pos += x_velocity
+      y_pos += y_velocity
+
+      # Write the frame to the video file
+
+      if saveon:   
+        out.write(frame)
+      if showon:   
+        cv2.imshow('im_object', frame)
+        cv2.waitKey(300)
+
+
+
+  # Release the VideoWriter object and close all windows
+  out.release()
+  cv2.destroyAllWindows()
+
+
+
+# class Im_saveshow(Enum):
+#   SHOW      = 1
+#   SAVE      = 2
+#   SAVESHOW  = 3 
+
+objpath = os.path.join(os.getcwd(), 'examples', 'resources', 'car.png')
+
+
+for runcase in range(1, 6):
+
+  if runcase == 1: 
+    ''' linear 1: left to right '''
+    animate(objpath = objpath, motion = Motion_Type.LINEAR
+            , x0 = 0, y0 = FRAMEHEIGHT / 2, scaling = .5, rotate = True)
+
+  elif runcase == 2: 
+    ''' linear 2: top to bottom '''
+    animate(objpath = objpath, motion = Motion_Type.LINEAR
+            , x0 = FRAMEWIDTH / 2, y0 = 0, scaling = .5, rotate = True
+              , pathangle = 90)
+
+  elif runcase == 3: 
+    ''' linear 3: top left to bottom right '''
+    animate(objpath = objpath, motion = Motion_Type.LINEAR
+            , x0 = 0, y0 = 0, scaling = .5, rotate = True
+              , pathangle = np.arctan(FRAMEHEIGHT / FRAMEWIDTH) * 180 / np.pi)
+
+  elif runcase == 4: 
+    ''' parabole 1: top left to top right '''
+    animate(objpath = objpath, motion = Motion_Type.PARABOLE, x0 = 0, y0 = 0, scaling = .5)
+
+  elif runcase == 5: 
+    ''' sinusoid 1: left to right '''
+    animate(objpath = objpath, motion = Motion_Type.SINE, x0 = 0, y0 = FRAMEHEIGHT / 2, scaling = .5)
+
+ 
+

c4dynamics/utils/vidgen.py

@@ -0,0 +1,182 @@
+import sys, os, re
+# print(sys.version)
+import natsort
+
+from pptx import Presentation
+from pptx.util import Inches
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+
+from lxml import etree
+import tkinter as tk
+from tkinter import filedialog
+
+
+
+
+
+
+edit_existing = True # False # 
+imfol = 'cars2_short/accsize2model' # 'cars2_short/velmodel' # 
+delimages = False
+
+
+
+
+
+
+
+
+# Path to the folder containing images
+folder_path = os.path.join('D:/', 'Dropbox', 'c4dynamics', 'examples', '_out', imfol)
+# print(folder_path)
+# Create a PowerPoint presentation object
+
+if edit_existing: 
+    root = tk.Tk()
+    root.withdraw()  # Hide the root window
+
+    # Bring the root window to the front
+    root.lift()
+    root.attributes("-topmost", True)
+    root.after_idle(root.attributes, '-topmost', False)
+
+
+    # Open a file dialog to select the PowerPoint file
+    pptfile = filedialog.askopenfilename(
+        title="Select PowerPoint File",
+        filetypes=[("PowerPoint files", "*.pptx")]
+    )
+
+else:
+  pptfile = None
+
+prs = Presentation(pptfile)
+prs.slide_width = Inches(20)
+prs.slide_height = Inches(11.25)
+
+
+namespace = {
+    'p': 'http://schemas.openxmlformats.org/presentationml/2006/main'
+}
+advance_after = 33 # msec 
+duration = 10 # msec 
+
+
+pattern = re.compile(r'\d+.*\.png$')
+
+
+filelist = natsort.natsorted(os.listdir(folder_path)) 
+# imgfiles = [f for f in dirfiles if f.lower().endswith(('.png', '.jpg', '.jpeg', 'bmp', '.tiff'))] 
+
+
+# Loop through each file in the folder
+cnt = 0
+for file_name in filelist:
+  if pattern.match(file_name):
+    print(file_name)
+    # if cnt > 10: break
+
+    if edit_existing:
+
+
+      slide = prs.slides[cnt]
+
+      shapes_to_remove = []
+
+      for shape in slide.shapes: 
+        # if shape.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE:
+        #     print('  - AutoShape.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.CHART:
+        #     print('  - Chart.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.FREEFORM:
+        #     print('  - Freeform.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+        #     print('  - Group.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+        #     print('  - Picture.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.PLACEHOLDER:
+        #     print('  - Placeholder.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.TABLE:
+        #     print('  - Table.')
+        # elif shape.shape_type == MSO_SHAPE_TYPE.TEXT_BOX:
+        #     print('  - Text Box.')
+        # else:
+        #     print('  - This is another type of shape.')
+
+        # print(shape.shape_type.value)
+        if shape.shape_type == 13:
+          shapes_to_remove.append(shape)
+          
+
+
+
+      for shape in shapes_to_remove:
+        sp = shape._element
+        sp.getparent().remove(sp)
+        #   if shape.shape_type == MSO_SHAPE_TYPE.AUTO_SHAPE:
+        #       print('  - AutoShape removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.CHART:
+        #       print('  - Chart removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.FREEFORM:
+        #       print('  - Freeform removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+        #       print('  - Group removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
+        #       print('  - Picture removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.PLACEHOLDER:
+        #       print('  - Placeholder removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.TABLE:
+        #       print('  - Table removed.')
+        #   elif shape.shape_type == MSO_SHAPE_TYPE.TEXT_BOX:
+        #       print('  - Text Box removed.')
+        #   else:
+        #       print('  - a shape removed')
+        # print(shape.shape_type.value, end = '')
+        # print('removed')
+    
+    else: 
+      # Add a slide
+      slide = prs.slides.add_slide(prs.slide_layouts[6])
+
+
+    # Define the path to the image file
+    img_path = os.path.join(folder_path, file_name)
+    # Add the image to the slide
+    picture = slide.shapes.add_picture(img_path, Inches(0), Inches(0), width=prs.slide_width, height=prs.slide_height)
+    # slide.shapes._spTree.remove(picture._element)  # Temporarily remove the picture element
+    slide.shapes._spTree.insert(2, picture._element)  # Re-insert it at the back
+
+    # set_slide_timing(slide, duration=0.01, advance_after=0.03)
+    # Namespaces required for the XML elements
+    
+    # Access the slide's XML
+    slide_xml = slide._element
+
+    # Create timing and transition elements
+    timing = etree.SubElement(slide_xml, '{http://schemas.openxmlformats.org/presentationml/2006/main}timing')
+    
+    # Duration of the transition (in milliseconds)
+    transition = etree.SubElement(slide_xml, '{http://schemas.openxmlformats.org/presentationml/2006/main}transition')
+    transition.set('dur', str(int(duration * 1000)))
+
+    # Set advance timing (in milliseconds)
+    advance = etree.SubElement(timing, '{http://schemas.openxmlformats.org/presentationml/2006/main}advAfter')
+    advance.text = str(int(advance_after * 1000))
+
+    cnt += 1
+
+# Save the presentation
+outfile = pptfile if pptfile else os.path.join(folder_path, os.path.basename(folder_path) + '.pptx') 
+try:
+  prs.save(outfile)
+  print('saved ' + outfile)
+except PermissionError:
+  prs.save(outfile[:-5] + '_v1' + '.pptx')
+  print('saved ' + outfile[:-5] + '_v1' + '.pptx')
+
+
+if delimages:
+  for file_name in filelist:
+    if pattern.match(file_name):
+        os.remove(os.path.join(folder_path, file_name))
+