nmixstudio 1.0.0__tar.gz

nmixstudio-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+recursive-include NMIXStudio/Docs *
+recursive-include NMIXStudio/Samples *

nmixstudio-1.0.0/NMIXStudio/Container/NmiContainer/__init__.py

@@ -0,0 +1,2 @@
+from .container import*
+from .containerBuilder import*

nmixstudio-1.0.0/NMIXStudio/Container/NmiContainer/container.py

@@ -0,0 +1,108 @@
+from NMIXStudio.Container.NmiFrame import*
+from NMIXStudio.Container.NmiImage import NMIImage
+from NMIXStudio.Container.NmiImage import NMIImageBuilder
+from NMIXStudio.Container.NmiContainer.enums import*
+import json
+from datetime import datetime 
+
+class NMIContainer():
+    def  __init__(self,containerName:str = None):
+        if(containerName is None):
+            containerName = "Default_" + datetime.now().strftime("%Y%m%d%H%M%S")
+        self.containerName = containerName
+        self.ImageList = [] 
+        self.WidthPixel:int = None
+        self.HeightPixel:int = None
+        self.RealHeight:float = None
+        self.RealWidth:float = None
+        self.RealHeightUnit:ScaleUnit = None
+        self.RealWidthUnit:ScaleUnit = None
+        self.RealHeightUnitPrefix:ScalePrefix = None
+        self.RealWidthUnitPrefix:ScalePrefix = None
+
+    def AddNewImage(self,frameType:FrameChannels,realBufferUnit:ScaleUnit = ScaleUnit.Meter,realBufferUnitPrefix:ScalePrefix = ScalePrefix.micro):
+        self.NMIImageBuilder = NMIImageBuilder()
+        newImage = (self.NMIImageBuilder
+                    .SetChannel(frameType)
+                    .SetWidthPixe(self.WidthPixel)
+                    .SetHeightPixel(self.HeightPixel)
+                    .SetRealHeight(self.RealHeight)
+                    .SetRealWidth(self.RealWidth)
+                    .SetRealHeightUnitPrefix(self.RealHeightUnitPrefix)
+                    .SetRealWidthUnitPrefix(self.RealWidthUnitPrefix)
+                    .SetRealHeightUnit(self.RealHeightUnit)
+                    .SetRealWidthUnit(self.RealWidthUnit)
+                    .SetRealBufferUnit(realBufferUnit)
+                    .SetRealBufferUnitPrefix(realBufferUnitPrefix)
+                    .Build())
+        self.ImageList.append(newImage)
+
+    def GetImageFromChannel(self,channel:FrameChannels)->NMIImage:
+        for image in self.ImageList:
+            image: NMIImage = image
+            if image.channel == channel:
+                return image
+        return None
+    
+    def GetFrameFromChannel(self,channel:FrameChannels)->NMIFrame:
+        for image in self.ImageList:
+            image: NMIImage = image
+            if image.channel == channel:
+                return image.GetFirstFrame()
+        return None
+
+    def AddPixelToRawBuffer_FromAPIRequest(self,data):
+        for image in self.ImageList:
+            image: NMIImage = image
+            image.AddPixelToRawBuffer_FromAPIRequest(data)
+       
+    def GetImageList(self):
+        return self.ImageList
+    
+    def _GetJsonObject(self):
+        jsonObject = {
+            "ContainerName": self.containerName,
+            "WidthPixel": self.WidthPixel,
+            "HeightPixel": self.HeightPixel,
+            "RealHeight": self.RealHeight,
+            "RealWidth": self.RealWidth,
+            "RealHeightUnit": self.RealHeightUnit.name,
+            "RealWidthUnit": self.RealWidthUnit.name,
+            "RealHeightUnitPrefix": self.RealHeightUnitPrefix.name,
+            "RealWidthUnitPrefix": self.RealWidthUnitPrefix.name,
+            "ImageList": self._GetImageListJsonObject()
+        }
+        return jsonObject
+
+    def _GetImageListJsonObject(self):
+        _list = []
+        for image in self.ImageList:
+            image:NMIImage = image
+            _list.append(image._GetJsonObject())
+        return _list
+
+    def Save(self,filename:str):
+        data = self._GetJsonObject()
+        with open(filename, 'w') as file:
+            json.dump(data, file, indent=4)
+
+    def _LoadFromJsonObject(self,data:dict):
+        self.containerName = data["ContainerName"]
+        self.WidthPixel = data["WidthPixel"]
+        self.HeightPixel = data["HeightPixel"]
+        self.RealHeight = data["RealHeight"]
+        self.RealWidth = data["RealWidth"]
+        self.RealHeightUnit = ScaleUnit[data["RealHeightUnit"]]
+        self.RealWidthUnit = ScaleUnit[data["RealWidthUnit"]]
+        self.RealHeightUnitPrefix = ScalePrefix[data["RealHeightUnitPrefix"]]
+        self.RealWidthUnitPrefix = ScalePrefix[data["RealWidthUnitPrefix"]]
+        self.ImageList = []
+        for image in data["ImageList"]:
+            newImage = NMIImage()
+            newImage._LoadFromJsonObject(image)
+            self.ImageList.append(newImage)
+    
+    def Load(self,filename:str):
+        with open(filename, 'r') as file:
+            data = json.load(file)
+            self._LoadFromJsonObject(data)

nmixstudio-1.0.0/NMIXStudio/Container/NmiContainer/containerBuilder.py

@@ -0,0 +1,40 @@
+from NMIXStudio.Container.NmiFrame import*
+from NMIXStudio.Container.NmiContainer import NMIContainer
+from NMIXStudio.Container.NmiContainer.enums import*
+
+class NMIContainerBuilder():
+    def __init__(self):
+        self.container = NMIContainer()
+    
+    def SetWidthPixel(self,width):
+        self.container.WidthPixel = width
+        return self
+    def SetHeightPixel(self,height):
+        self.container.HeightPixel = height
+        return self
+    def SetRealHeight(self,height):
+        self.container.RealHeight = height
+        return self
+    def SetRealWidth(self,width):
+        self.container.RealWidth = width
+        return self
+    def SetRealHeightUnit(self,unit:ScaleUnit):
+        self.container.RealHeightUnit = unit
+        return self
+    def SetRealWidthUnit(self,unit:ScaleUnit):
+        self.container.RealWidthUnit = unit
+        return self
+    
+    def SetRealHeightUnitPrefix(self,prefix:ScalePrefix):
+        self.container.RealHeightUnitPrefix = prefix
+        return self
+    def SetRealWidthUnitPrefix(self,prefix:ScalePrefix):
+        self.container.RealWidthUnitPrefix = prefix
+        return self
+    
+    def AddImageChannel(self,channel:FrameChannels):
+        self.container.AddNewImage(channel)
+        return self
+
+    def Build(self):
+        return self.container

nmixstudio-1.0.0/NMIXStudio/Container/NmiContainer/enums.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+class ScalePrefix(Enum):
+    giga = 0
+    mega = 1
+    kilo = 2
+    one = 3
+    milli = 4
+    micro = 5
+    nano = 6
+    angstrom = 7
+    pico = 8
+    femto = 9
+
+class ScaleUnit(Enum):
+    Volt = 0
+    Amper = 1
+    Hertz = 2
+    Meter = 3
+    Gram = 4
+    Gauss = 5
+    Degrees = 6
+    Newton = 7
+    Farad = 8
+    Ohm = 9
+    VoltRms = 10

nmixstudio-1.0.0/NMIXStudio/Container/NmiFrame/__init__.py

@@ -0,0 +1,2 @@
+from .frame import*
+from .frameChannels import*

nmixstudio-1.0.0/NMIXStudio/Container/NmiFrame/frame.py

@@ -0,0 +1,72 @@
+from NMIXStudio.Container.NmiFrame.frameChannels import FrameChannels, GetAPIResponseKeyForChannel
+import numpy as np
+
+class NMIFrame():
+    def __init__(self,width:int,height:int,channel:FrameChannels):
+        self.channel:FrameChannels=channel
+        self.width:int=width
+        self.height:int=height
+        self.rawBuffer = []
+        self.realBuffer = []
+      
+    def Get8BitImageData(self)->np.array:
+        image_data = np.array(self.rawBuffer).reshape((self.height, self.width))
+        image_data = ((image_data - np.min(image_data)) / (np.max(image_data) - np.min(image_data)) * 255).astype(np.uint8)
+        return image_data
+
+    def Get16BitImageData(self) -> np.array:
+        image_data = np.array(self.rawBuffer).reshape((self.height, self.width))
+        # Veriyi normalize et ve 16-bit'e ölçekle
+        image_data = ((image_data - np.min(image_data)) / (np.max(image_data) - np.min(image_data)) * 65535).astype(np.uint16)
+        return image_data
+
+    def GetRawImageData(self) -> np.array:
+        image_data = np.array(self.rawBuffer).reshape((self.height, self.width))
+        return image_data
+
+    def UpdateFrameRawBuffer_FromAPIRequest(self,data:dict):
+        if "RawBuffer" not in data:
+            return None
+        data_string = data["RawBuffer"]  
+        self.rawBuffer = np.array([int(x) for x in data_string.split(";")], dtype=np.int32)
+       
+    def UpdateFrameRealBuffer_FromAPIRequest(self,data:dict):
+        if "RealBuffer" not in data:
+            return None
+        data_string = data["RealBuffer"]  
+        data = np.array([int(x) for x in data_string.split(";")], dtype=np.int32)
+        self.realBuffer = data.reshape(self.height,self.width)
+    
+    def AddPixelToRawBuffer_FromAPIRequest(self,data:dict):
+        key = GetAPIResponseKeyForChannel(self.channel)
+        if key is None:
+            return None
+        if key not in data:
+            return None 
+        _bufferData = float(data[key])
+        self.rawBuffer.append(_bufferData)
+
+    def AddPixelToRawBuffer(self,data:float):
+        self.rawBuffer.append(data)
+
+    def AddPixelToRealBuffer(self,data):
+        self.realBuffer.append(data)
+
+    def _GetJsonObject(self):
+        jsonObject = {
+            "Width": self.width,
+            "Height": self.height,
+            "RawBuffer": self.rawBuffer,
+            "RealBuffer": self.realBuffer
+        }
+        return jsonObject
+    
+    def _LoadFromJsonObject(self,data:dict):
+        self.width = data["Width"]
+        self.height = data["Height"]
+        self.rawBuffer = data["RawBuffer"]
+        self.realBuffer = data["RealBuffer"]
+
+
+    
+    

nmixstudio-1.0.0/NMIXStudio/Container/NmiFrame/frameChannels.py

@@ -0,0 +1,79 @@
+from enum import Enum
+
+class FrameChannels(Enum):
+    Channel_Vz = 0,
+    Channel_Phase1 = 1,
+    Channel_Phase2 = 2,
+    Channel_Rms1 = 3,
+    Channel_Rms2 = 4,
+    Channel_WorkFunction = 5,
+    Channel_VHall = 6,
+    Channel_IHall = 7,
+    Channel_Spare3 = 8,
+    Channel_Spare4 = 9,
+    Channel_Vpd = 10,
+    Channel_VpdRef = 11,
+    Channel_VpdSig = 12,
+    Channel_Spare8 = 13,
+    Channel_Spare9 = 14,
+    Channel_Spare10 = 15,
+    Channel_FN10 = 16,
+    Channel_FN = 17,
+    Channel_FL = 18,
+    Channel_FT = 19,
+    Channel_DeltaF = 20,
+    Channel_ITunnel = 21,
+
+    Channel_Custom1 = 31,
+    Channel_Custom2 = 32,
+    Channel_Custom3 = 33,
+    Channel_Custom4 = 34,
+    Channel_Custom5 = 35,
+
+   
+def GetAPIResponseKeyForChannel(channel:FrameChannels):
+    if channel == FrameChannels.Channel_Vz:
+        return "Vz"
+    if channel == FrameChannels.Channel_Phase1:
+        return "Lia1Phase"
+    if channel == FrameChannels.Channel_Phase2:
+        return "Lia2Phase"
+    if channel == FrameChannels.Channel_Rms1:
+        return "Lia1RMS"
+    if channel == FrameChannels.Channel_Rms2:
+        return "Lia2RMS"
+    if channel == FrameChannels.Channel_WorkFunction:
+        return "WorkFunction"
+    if channel == FrameChannels.Channel_VHall:
+        return "VHall"
+    if channel == FrameChannels.Channel_IHall:
+        return "IHall"
+    if channel == FrameChannels.Channel_ITunnel:
+        return "It"
+    if channel == FrameChannels.Channel_Spare3:
+        return "Spare3"
+    if channel == FrameChannels.Channel_Spare4:
+        return "Spare4"
+    if channel == FrameChannels.Channel_Vpd:
+        return "Vpd"
+    if channel == FrameChannels.Channel_VpdRef:
+        return "VpdRef"
+    if channel == FrameChannels.Channel_VpdSig:
+        return "VpdSig"
+    if channel == FrameChannels.Channel_Spare8:
+        return "Spare8"
+    if channel == FrameChannels.Channel_Spare9:
+        return "Spare9"
+    if channel == FrameChannels.Channel_Spare10:
+        return "Spare10"
+    if channel == FrameChannels.Channel_FN10:
+        return "Fnx10"
+    if channel == FrameChannels.Channel_FN:
+        return "Fn"
+    if channel == FrameChannels.Channel_FL:
+        return "Fl"
+    if channel == FrameChannels.Channel_FT:
+        return "Ft"
+    if channel == FrameChannels.Channel_DeltaF:
+        return "DeltaF"
+    return ""

nmixstudio-1.0.0/NMIXStudio/Container/NmiImage/__init__.py

@@ -0,0 +1,2 @@
+from .image import*
+from .imageBuilder import*

nmixstudio-1.0.0/NMIXStudio/Container/NmiImage/image.py

@@ -0,0 +1,89 @@
+from NMIXStudio.Container.NmiFrame import*
+from NMIXStudio.Container.NmiContainer.enums import*
+
+class NMIImage():
+    def __init__(self):
+        self.imageName = None
+        self.WidthPixel:int = None
+        self.HeightPixel:int = None
+        self.RealHeight:float = None
+        self.RealWidth:float = None
+        self.RealHeightUnit:ScaleUnit = None
+        self.RealWidthUnit:ScaleUnit = None
+        self.RealHeightUnitPrefix:ScalePrefix = None
+        self.RealWidthUnitPrefix:ScalePrefix = None
+        self.RealBufferUnit:ScaleUnit = None
+        self.RealBufferUnitPrefix:ScalePrefix = None
+        self.channel:FrameChannels = None
+        self.frameList = []
+
+    def AddPixelToRawBuffer_FromAPIRequest(self,data:dict,index = 0):
+        frame:NMIFrame = self.frameList[index]
+        frame.AddPixelToRawBuffer_FromAPIRequest(data)
+
+    def UpdateFrameRawBuffer_FromAPIRequest(self,data:dict,index = 0):
+        frame:NMIFrame = self.frameList[index]
+        frame.UpdateFrameRawBuffer_FromAPIRequest(data)
+
+    def AddPixelToRealBuffer(self,data:dict,index = 0):
+        frame:NMIFrame = self.frameList[index]
+        frame.AddPixelToRealBuffer(data)
+
+    def AddPixelToRawBuffer(self,data,index = 0):
+        frame:NMIFrame = self.frameList[index]
+        frame.AddPixelToRawBuffer(data)
+
+    def CreateNewFrame(self):
+        newFrame = NMIFrame(self.WidthPixel,self.HeightPixel,self.channel)
+        self.frameList.append(newFrame)
+   
+    def GetFrameList(self):
+        return self.frameList
+    
+    def GetFirstFrame(self)->NMIFrame:
+        return self.frameList[0]
+
+    def _GetJsonObject(self):
+        jsonObject = {
+            "ImageName": self.imageName,
+            "WidthPixel": self.WidthPixel,
+            "HeightPixel": self.HeightPixel,
+            "RealHeight": self.RealHeight,
+            "RealWidth": self.RealWidth,
+            "RealHeightUnit": self.RealHeightUnit.name,
+            "RealWidthUnit": self.RealWidthUnit.name,
+            "RealHeightUnitPrefix": self.RealHeightUnitPrefix.name,
+            "RealWidthUnitPrefix": self.RealWidthUnitPrefix.name,
+            "RealBufferUnit": self.RealBufferUnit.name,
+            "RealBufferUnitPrefix": self.RealBufferUnitPrefix.name,
+            "Channel": self.channel.name,
+            "Frames": self._GetJsonObjectFrameList()
+        }
+        return jsonObject
+
+    def _GetJsonObjectFrameList(self):
+        _list = []
+        for frame in self.frameList:
+            frame:NMIFrame = frame
+            _list.append(frame._GetJsonObject())
+        return _list
+    
+    def _LoadFromJsonObject(self,data:dict):
+        self.imageName = data["ImageName"]
+        self.WidthPixel = data["WidthPixel"]
+        self.HeightPixel = data["HeightPixel"]
+        self.RealHeight = data["RealHeight"]
+        self.RealWidth = data["RealWidth"]
+        self.RealHeightUnit = ScaleUnit[data["RealHeightUnit"]]
+        self.RealWidthUnit = ScaleUnit[data["RealWidthUnit"]]
+        self.RealHeightUnitPrefix = ScalePrefix[data["RealHeightUnitPrefix"]]
+        self.RealWidthUnitPrefix = ScalePrefix[data["RealWidthUnitPrefix"]]
+        self.RealBufferUnit = ScaleUnit[data["RealBufferUnit"]]
+        self.RealBufferUnitPrefix = ScalePrefix[data["RealBufferUnitPrefix"]]
+        self.channel = FrameChannels[data["Channel"]]
+        for frameData in data["Frames"]:
+            frame = NMIFrame(self.WidthPixel,self.HeightPixel,self.channel)
+            frame._LoadFromJsonObject(frameData)
+            self.frameList.append(frame)
+    
+ 

nmixstudio-1.0.0/NMIXStudio/Container/NmiImage/imageBuilder.py

@@ -0,0 +1,55 @@
+from NMIXStudio.Container.NmiImage.image import NMIImage
+from NMIXStudio.Container.NmiContainer.enums import*
+from NMIXStudio.Container.NmiFrame.frameChannels import*
+class NMIImageBuilder():
+    def __init__(self):
+        self.Image = NMIImage()
+        pass
+    
+    def SetWidthPixe(self,width):
+        self.Image.WidthPixel = width
+        return self
+
+    def SetHeightPixel(self,height):
+        self.Image.HeightPixel = height
+        return self
+
+    def SetRealHeight(self,height):
+        self.Image.RealHeight = height
+        return self
+    
+    def SetRealWidth(self,width):
+        self.Image.RealWidth = width
+        return self
+    
+    def SetRealHeightUnit(self,unit:ScaleUnit):
+        self.Image.RealHeightUnit = unit
+        return self
+    
+    def SetRealWidthUnit(self,unit:ScaleUnit):
+        self.Image.RealWidthUnit = unit
+        return self
+
+    def SetRealHeightUnitPrefix(self,prefix:ScalePrefix):
+        self.Image.RealHeightUnitPrefix = prefix
+        return self
+    
+    def SetRealWidthUnitPrefix(self,prefix:ScalePrefix):
+        self.Image.RealWidthUnitPrefix = prefix
+        return self
+    
+    def SetRealBufferUnit(self,unit:ScaleUnit):
+        self.Image.RealBufferUnit = unit
+        return self
+    def SetRealBufferUnitPrefix(self,prefix:ScalePrefix):
+        self.Image.RealBufferUnitPrefix = prefix
+        return self
+    
+    def SetChannel(self,channel:FrameChannels):
+        self.Image.channel = channel
+        self.Image.imageName = channel.name
+        return self
+        
+    def Build(self)->NMIImage:
+        self.Image.CreateNewFrame()
+        return self.Image

nmixstudio-1.0.0/NMIXStudio/Container/__init__.py

@@ -0,0 +1,3 @@
+from .NmiContainer import*
+from .NmiFrame import*
+from .NmiImage import*

nmixstudio-1.0.0/NMIXStudio/ExternalDevices/Devices/AndorCamera.py

@@ -0,0 +1,109 @@
+from .utils import ExternalScanDevice
+from pylablib.devices import Andor
+import numpy as np
+from enum import Enum
+
+
+class ReadMode(Enum):
+    FVB = "fvb"
+    IMAGE = "image"
+
+class TriggerMode(Enum):
+    INTERNAL = "int"
+    EXTERNAL = "ext"
+
+class AcquisitionMode(Enum):
+    SINGLE = "single"
+    ACCUM = "accum"
+
+class AndorCamera(ExternalScanDevice):
+    def __init__(self):
+        self.camera = None
+
+    def connect(self):
+        """Connect to the Andor camera."""
+        camera_count = Andor.get_cameras_number_SDK2()
+        if camera_count == 0:
+            raise Exception("No cameras found.")
+        self.camera = Andor.AndorSDK2Camera()
+        print("Camera connected.")
+
+    def disconnect(self):
+        """Disconnect the camera."""
+        if self.camera and self.camera.is_opened():
+            self.camera.close()
+            print("Camera disconnected.")
+
+    def set_temperature(self, temperature):
+        """Set the camera temperature."""
+        if self.camera:
+            self.camera.set_temperature(temperature)
+            self.camera.set_cooler()
+            print(f"Temperature set to {temperature}C.")
+
+    def get_status(self):
+        """Get the current status of the camera."""
+        if self.camera:
+            return self.camera.get_full_status()
+        return None
+
+    def get_info(self):
+        """Get full camera information."""
+        if self.camera:
+            return self.camera.get_full_info()
+        return None
+
+    def set_exposure(self, exposure_time):
+        """Set the exposure time."""
+        if self.camera:
+            self.camera.set_exposure(exposure_time)
+            print(f"Exposure time set to {exposure_time} seconds.")
+
+    def configure_acquisition(self, mode=AcquisitionMode.SINGLE, read_mode=ReadMode.FVB, trigger_mode=TriggerMode.INTERNAL, amp_settings=None):
+        """Configure acquisition settings."""
+        if self.camera:
+            self.camera.set_read_mode(read_mode.value)
+            self.camera.set_trigger_mode(trigger_mode.value)
+            self.camera.setup_shutter("auto")
+
+            if amp_settings:
+                self.camera.set_amp_mode(
+                    channel=amp_settings.get("channel", 0),
+                    oamp=amp_settings.get("oamp", 1),
+                    hsspeed=amp_settings.get("hsspeed", 2),
+                    preamp=amp_settings.get("preamp", 2),
+                )
+            
+            self.camera.setup_acquisition(mode.value)
+            print(f"Acquisition configured. Mode: {mode.name}, Read Mode: {read_mode.name}, Trigger Mode: {trigger_mode.name}.")
+
+    def acquire_spectrum(self):
+        """Acquire a Raman spectrum."""
+        if self.camera:
+            spectrum = self.camera.snap()        
+            return spectrum[0]  # Return the spectral data
+        return None
+
+    def start_acquisition(self):
+        """Start acquisition."""
+        if self.camera:
+            self.camera.start_acquisition()
+            print("Acquisition started.")
+
+    def stop_acquisition(self):
+        """Stop acquisition."""
+        if self.camera:
+            self.camera.stop_acquisition()
+            print("Acquisition stopped.")
+
+    def clear_acquisition(self):
+        """Clear acquisition settings."""
+        if self.camera:
+            self.camera.clear_acquisition()
+            print("Acquisition cleared.")
+
+    
+    def GetScanData(self) -> float:
+        return None
+
+