Untitled

## Cleint Sender
import socket
import io
import sys, time, struct
import cv2 as cv
import numpy as np

TCP_IP = socket.gethostbyname(socket.gethostname())
TCP_PORT = 12346
BUFFER_SIZE = 4096
FPS = 30

class ClientSender():
    def __init__(self, server_ip, server_port, buffer_size = 4096):
        self.server_ip = server_ip
        self.server_port = server_port
        self.buffer_size = buffer_size

    def start_server(self):
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client_socket.connect((self.server_ip, self.server_port))

        return client_socket

    def send_image(self, image_path):
        try:
            client_socket = self.start_server()

            cnt = 0
            is_img = False

            while True:
                #while True:
                if cnt == 0:
                    is_img = self.send_helper(image_path[0], client_socket)
                    cnt = (cnt + 1) % 2
                
                else:
                    is_img = self.send_helper(image_path[1], client_socket)
                    cnt = (cnt + 1) % 2

                if is_img:
                    break

                

        except Exception as e:
            print(f"Error: {e}")

    def send_helper(self, image_path, client_socket):
        img = cv.imread(image_path)

        if img is None:
            print("Error: coult not read the image file")
            return True
        
        # Encode
        _, img_encoded = cv.imencode(".png", img)
        data = img_encoded.tobytes()

        # Create socket

        # Send image length
        data_size = len(data)
        msg_len = struct.pack(">L", data_size)
        client_socket.sendall(msg_len)
        
        print(f"Size of image: {data_size}")
        # print(f"Msg len: {msg_len}")

        # Send image data
        client_socket.sendall(data)

        print(f"Image {image_path} sent to server.")

        time.sleep(1/FPS)
        
def main():
    # if len(sys.argv) != 3:
    #     print("Usage: python client.py <image_path_1> <image_path_2>")
    #     sys.exit()

    # print(sys.argv[1])
    # print(sys.argv[2])
    image_path =("D:\\test.png", "D:\\test1.png")

    sender = ClientSender(TCP_IP, TCP_PORT)
    sender.send_image(image_path)

if __name__ == "__main__":
    main()

## Server Receiver and Sender

import socket
import sys, time
from threading import Thread
import cv2 as cv
import numpy as np
import struct

TCP_IP = socket.gethostbyname(socket.gethostname())
TCP_PORT = 12346
BUFFER_SIZE = 4096
FIXED_BYTE_LENGTH = 47939

clientCount = 0

class recvServer():

    def __init__(self):
        self.CLIENTS = []
        print("Receiving server constructed!")

    def startServer(self):
        try:
            server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server.bind((TCP_IP, TCP_PORT))
            server.listen(5)

            print(f"Receiving image on {TCP_IP} and {TCP_PORT}")

            clientSocket, addr = server.accept()
            print("Connected from: " + addr[0] + ":" + str(addr[1]))
            
            global clientCount
            clientCount += 1
            print("Number of connected clients: " + str(clientCount))

            while True:
               
                # register client
                self.CLIENTS.append(clientSocket)

                # Handle each client in a separate thread
                if not self.receiverHandler(clientSocket):
                    break
                # Thread(target=self.receiverHandler, args=(clientSocket, )).start()

        except KeyboardInterrupt:
                print("\nShutting down server.")
            
        except socket.error as e:
            print(f"Could not Start Server. Error Code: {e}")

        finally:
            server.close()
            sys.exit()

    # Receiving Clint Socket
    
    def receiverHandler(self, clientSocket):
        try:
            data_length = self.get_length(clientSocket)

            data = self.recvAll(clientSocket, data_length)

            if data:
                nparr = np.frombuffer(data, np.uint8)
                img = cv.imdecode(nparr, cv.IMREAD_COLOR)

                if img is not None:
                    cv.imshow("Received Image", img)
                    cv.waitKey(1)
                        #cv.destroyAllWindows()
                        #return False
                    # cv.destroyAllWindows()
                else:
                    print("Failed to decode image")

            # clientSocket.close()
            return True

        except Exception as e:
            print(f"Error occurred while receiving byteArray data: {e}")
            return True

    # when sending multiple images/frames, needs to retrieve the first lengths of data
    # avoiding infinite loop in recv all due to While True
    def get_length(self, clientSocket):
        msg_len = clientSocket.recv(4)

        data_length = struct.unpack(">L", msg_len)[0]

        return data_length
        
    def recvAll(self, clientSocket, data_length):
        data = b''
        try:

            remaining_size = data_length

            while len(data) < data_length:

                if remaining_size > BUFFER_SIZE:
                    remaining_size -= BUFFER_SIZE
                    chunk = clientSocket.recv(BUFFER_SIZE)

                    # time.sleep(0.0005)

                    if not chunk:
                        break
                    data += chunk
                else:
                    chunk = clientSocket.recv(remaining_size)

                    if not chunk:
                        break
                    data += chunk

            if data_length == len(data):
                return data
            else:
                return None
            
        except Exception as e:
            print(f"Error occurred while receiving data: {e}")
            return None
        
def main():
    recvS = recvServer()
    recvS.startServer()

if __name__ == "__main__":
    main()

## Client Receiver
import cv2 as cv
import struct, socket, os, sys, time
from threading import Thread
import numpy as np

TCP_IP = socket.gethostbyname(socket.gethostname())
TCP_PORT = 123456
BUFFER_SIZE = 4096
FIXED_BYTE_LENGTH = 47939

class ClientReceiver():

    def __init__(self, server_ip, server_port, buffer_size=4096):
        self.server_ip = server_ip
        self.server_port = server_port
        self.buffer_size = buffer_size

    def start_server(self):
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client_socket.connect((self.server_ip, self.server_port))

        return  client_socket
    
    def receive_image(self):
        try:
            client_socket = self.start_server()

            while True:
                if not self.receiverHandler(client_socket)
                break
    
    def receiverHandler(self, client_socket):
        try:
            data_length = self.get_length(client_socket)

            data = self.recvAll(client_socket, data_length)

            if data:
                nparr = np.frombuffer(data, np.uint8)
                img = cv.imdecode(nparr, cv.IMREAD_COLOR)

                if img is not None:
                    cv.imshow("Received Image", img)
                    cv.waitKey(1)
                        #cv.destroyAllWindows()
                        #return False
                    # cv.destroyAllWindows()
                else:
                    print("Failed to decode image")

            # client_socket.close()
            return True

        except Exception as e:
            print(f"Error occurred while receiving byteArray data: {e}")
            return True

    # when sending multiple images/frames, needs to retrieve the first lengths of data
    # avoiding infinite loop in recv all due to While True
    def get_length(self, client_socket):
        msg_len = client_socket.recv(4)

        data_length = struct.unpack(">L", msg_len)[0]

        return data_length
        
    def recvAll(self, client_socket, data_length):
        data = b''
        try:

            remaining_size = data_length

            while len(data) < data_length:

                if remaining_size > BUFFER_SIZE:
                    remaining_size -= BUFFER_SIZE
                    chunk = client_socket.recv(BUFFER_SIZE)

                    # time.sleep(0.0005)

                    if not chunk:
                        break
                    data += chunk
                else:
                    chunk = client_socket.recv(remaining_size)

                    if not chunk:
                        break
                    data += chunk

            if data_length == len(data):
                return data
            else:
                return None
            
        except Exception as e:
            print(f"Error occurred while receiving data: {e}")
            return None