title: Unable to save image from Raspi camera -> cv2.imwrite (Using Jetson Nano)
body: <p>I am trying to save images from the Raspi cameras connected to my Jetson nano. My Code is below. However, the code shows that it is saving the files, but no matter which method I try I cannot find the images. Thanks for your help. I've included a smaller snippet of just the while loop itself so it will be easier for you all to refer to.</p>
  <p>While loop:</p>
  <pre><code>while True:
              
              _ , left_image=left_camera.read()
              _ , right_image=right_camera.read()
              camera_images = np.hstack((left_image, right_image))
              cv2.imshow(&quot;CSI Cameras&quot;, camera_images)
              
      
      
              t1 = datetime.now()
              cntdwn_timer = countdown - int ((t1-t2).total_seconds())
              # If cowntdown is zero - let's record next image
              if cntdwn_timer == -1:
                  counter += 1
      
                  filename = './scenes/scene_'+ str(counter) + 'x'+'_'+ '.png'
                  #img = cv2.imread(camera_images)
                  #cv2.imwrite(os.path.join(os.path.expanduser('~'),'CSI-Camera', filename), camera_images)
                  cv2.imwrite('/home/aryan/CSI-Camera/{}'.format(filename), camera_images)
                  print (' monkey'+filename)
                  t2 = datetime.now()
                  time.sleep(1)
                  cntdwn_timer = 0      # To avoid &quot;-1&quot; timer display 
                  next
              
      
              # This also acts as
              keyCode = cv2.waitKey(30) &amp; 0xFF
              # Stop the program on the ESC key
              if keyCode == 27:
                  break
      
          left_camera.stop()
          left_camera.release()
          right_camera.stop()
          right_camera.release()
          cv2.destroyAllWindows()
      
  
   
  
  import cv2
  import threading
  import numpy as np
  import time
  from datetime import datetime
  
  # gstreamer_pipeline returns a GStreamer pipeline for capturing from the CSI camera
  # Flip the image by setting the flip_method (most common values: 0 and 2)
  # display_width and display_height determine the size of each camera pane in the window on the screen
  
  left_camera = None
  right_camera = None
  
  #PiCam
  # Photo session settings
  total_photos = 30             # Number of images to take
  countdown = 5                 # Interval for count-down timer, seconds
  font=cv2.FONT_HERSHEY_SIMPLEX # Cowntdown timer font
  
  
  class CSI_Camera:
  
      def __init__ (self) :
          # Initialize instance variables
          # OpenCV video capture element
          self.video_capture = None
          # The last captured image from the camera
          self.frame = None
          self.grabbed = False
          # The thread where the video capture runs
          self.read_thread = None
          self.read_lock = threading.Lock()
          self.running = False
  
  
      def open(self, gstreamer_pipeline_string):
          try:
              self.video_capture = cv2.VideoCapture(
                  gstreamer_pipeline_string, cv2.CAP_GSTREAMER
              )
              
          except RuntimeError:
              self.video_capture = None
              print(&quot;Unable to open camera&quot;)
              print(&quot;Pipeline: &quot; + gstreamer_pipeline_string)
              return
          # Grab the first frame to start the video capturing
          self.grabbed, self.frame = self.video_capture.read()
  
      def start(self):
          if self.running:
              print('Video capturing is already running')
              return None
          # create a thread to read the camera image
          if self.video_capture != None:
              self.running=True
              self.read_thread = threading.Thread(target=self.updateCamera)
              self.read_thread.start()
          return self
  
      def stop(self):
          self.running=False
          self.read_thread.join()
  
      def updateCamera(self):
          # This is the thread to read images from the camera
          while self.running:
              try:
                  grabbed, frame = self.video_capture.read()
                  with self.read_lock:
                      self.grabbed=grabbed
                      self.frame=frame
              except RuntimeError:
                  print(&quot;Could not read image from camera&quot;)
          # FIX ME - stop and cleanup thread
          # Something bad happened
          
  
      def read(self):
          with self.read_lock:
              frame = self.frame.copy()
              grabbed=self.grabbed
          return grabbed, frame
  
      def release(self):
          if self.video_capture != None:
              self.video_capture.release()
              self.video_capture = None
          # Now kill the thread
          if self.read_thread != None:
              self.read_thread.join()
  
  
  # Currently there are setting frame rate on CSI Camera on Nano through gstreamer
  # Here we directly select sensor_mode 3 (1280x720, 59.9999 fps)
  def gstreamer_pipeline(
      sensor_id=0,
      sensor_mode=3,
      capture_width=1280,
      capture_height=720,
      display_width=1280,
      display_height=720,
      framerate=30,
      flip_method=0,
  ):
      return (
          &quot;nvarguscamerasrc sensor-id=%d sensor-mode=%d ! &quot;
          &quot;video/x-raw(memory:NVMM), &quot;
          &quot;width=(int)%d, height=(int)%d, &quot;
          &quot;format=(string)NV12, framerate=(fraction)%d/1 ! &quot;
          &quot;nvvidconv flip-method=%d ! &quot;
          &quot;video/x-raw, width=(int)%d, height=(int)%d, format=(string)BGRx ! &quot;
          &quot;videoconvert ! &quot;
          &quot;video/x-raw, format=(string)BGR ! appsink&quot;
          % (
              sensor_id,
              sensor_mode,
              capture_width,
              capture_height,
              framerate,
              flip_method,
              display_width,
              display_height,
          )
      )
  
  
  def start_cameras():
      left_camera = CSI_Camera()
      left_camera.open(
          gstreamer_pipeline(
              sensor_id=0,
              sensor_mode=3,
              flip_method=0,
              display_height=540,
              display_width=960,
          )
      )
      left_camera.start()
  
      right_camera = CSI_Camera()
      right_camera.open(
          gstreamer_pipeline(
              sensor_id=1,
              sensor_mode=3,
              flip_method=0,
              display_height=540,
              display_width=960,
          )
      )
      right_camera.start()
  
      cv2.namedWindow(&quot;CSI-AV Cameras&quot;, cv2.WINDOW_AUTOSIZE)
  
      if (
          not left_camera.video_capture.isOpened()
          or not right_camera.video_capture.isOpened()
      ):
          # Cameras did not open, or no camera attached
  
          print(&quot;Unable to open any cameras&quot;)
          # TODO: Proper Cleanup
          SystemExit(0)
  
      counter = 0
      t2 = datetime.now()
  #Main stuff here
      while True:
          
          _ , left_image=left_camera.read()
          _ , right_image=right_camera.read()
          camera_images = np.hstack((left_image, right_image))
          cv2.imshow(&quot;CSI Cameras&quot;, camera_images)
          
  
  
          t1 = datetime.now()
          cntdwn_timer = countdown - int ((t1-t2).total_seconds())
          # If cowntdown is zero - let's record next image
          if cntdwn_timer == -1:
              counter += 1
  
              filename = './scenes/scene_'+ str(counter) + 'x'+'_'+ '.png'
              #img = cv2.imread(camera_images)
              #cv2.imwrite(os.path.join(os.path.expanduser('~'),'CSI-Camera', filename), camera_images)
              cv2.imwrite('/home/aryan/CSI-Camera/{}'.format(filename), camera_images)
              print (' monkey'+filename)
              t2 = datetime.now()
              time.sleep(1)
              cntdwn_timer = 0      # To avoid &quot;-1&quot; timer display 
              next
          
  
          # This also acts as
          keyCode = cv2.waitKey(30) &amp; 0xFF
          # Stop the program on the ESC key
          if keyCode == 27:
              break
  
      left_camera.stop()
      left_camera.release()
      right_camera.stop()
      right_camera.release()
      cv2.destroyAllWindows()
  
  
  if __name__ == &quot;__main__&quot;:
      start_cameras()
  </code></pre>