Semapp 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

semapp/Plot/frame_attributes.py

@@ -51,6 +51,7 @@ class PlotFrame(QWidget):
         self.canvas_connection_id = None
         self.selected_wafer = None
         self.radius = None
+        self.is_complus4t_mode = False  # COMPLUS4T mode detected
         
         self._setup_frames()
         self._setup_plot()
@@ -101,8 +102,15 @@ class PlotFrame(QWidget):
         open_button.clicked.connect(self.open_tiff)
         self.layout.addWidget(open_button, 1, 5)
     
-    def extract_positions(self, filepath):
-
+    def extract_positions(self, filepath, wafer_id=None):
+        """
+        Extract defect positions from KLARF file.
+        
+        Args:
+            filepath: Path to the KLARF (.001) file
+            wafer_id: Specific wafer ID to extract (for COMPLUS4T files with multiple wafers)
+                     If None, extracts all defects (normal mode)
+        """
         data = {
             "SampleSize": None,
             "DiePitch": {"X": None, "Y": None},
@@ -112,44 +120,103 @@ class PlotFrame(QWidget):
         }
 
         dans_defect_list = False
+        current_wafer_id = None
+        target_wafer_found = False
+        reading_target_wafer = False
 
         with open(filepath, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-
-                if line.startswith("SampleSize"):
-                    match = re.search(r"SampleSize\s+1\s+(\d+)", line)
-                    if match:
-                        data["SampleSize"] = int(match.group(1))
-
-                elif line.startswith("DiePitch"):
-                    match = re.search(r"DiePitch\s+([0-9.]+)\s+([0-9.]+);", line)
-                    if match:
-                        data["DiePitch"]["X"] = float(match.group(1))
-                        data["DiePitch"]["Y"] = float(match.group(2))
-
-                elif line.startswith("DieOrigin"):
-                    match = re.search(r"DieOrigin\s+([0-9.]+)\s+([0-9.]+);", line)
-                    if match:
-                        data["DieOrigin"]["X"] = float(match.group(1))
-                        data["DieOrigin"]["Y"] = float(match.group(2))
-
-                elif line.startswith("SampleCenterLocation"):
-                    match = re.search(r"SampleCenterLocation\s+([0-9.]+)\s+([0-9.]+);", line)
-                    if match:
-                        data["SampleCenterLocation"]["X"] = float(match.group(1))
-                        data["SampleCenterLocation"]["Y"] = float(match.group(2))
-
-                elif line.startswith("DefectList"):
-                    dans_defect_list = True
+            lines = f.readlines()
+            
+        for i, line in enumerate(lines):
+            line = line.strip()
+
+            # Detect WaferID
+            if line.startswith("WaferID"):
+                match = re.search(r'WaferID\s+"@(\d+)"', line)
+                if match:
+                    current_wafer_id = int(match.group(1))
+                    
+                    # If looking for a specific wafer
+                    if wafer_id is not None:
+                        if current_wafer_id == wafer_id:
+                            target_wafer_found = True
+                            reading_target_wafer = True
+                            # Do NOT reset global data already read (DiePitch, etc.)
+                            # Only reset Defects
+                            data["Defects"] = []
+                        elif target_wafer_found:
+                            # Already found our wafer and reached another one
+                            # Stop reading
+                            break
+                        else:
+                            reading_target_wafer = False
+                    else:
+                        # Normal mode (no wafer_id specified)
+                        reading_target_wafer = True
+                continue
+
+            # If looking for specific wafer, skip lines until finding the right wafer
+            # EXCEPT for DefectList where we filter in the elif block
+            if wafer_id is not None and not reading_target_wafer and not line.startswith("DefectList"):
+                # Don't skip parameters before first WaferID
+                if current_wafer_id is None:
+                    # Haven't seen WaferID yet, read global parameters
+                    pass
+                else:
+                    # Seen a WaferID but it's not the right one, skip
                     continue
 
-                elif dans_defect_list:
-                    if re.match(r"^\d+\s", line):
-                        value = line.split()
-                        if len(value) >= 18:
-                            defect = {f"val{i+1}": float(val) for i, val in enumerate(value[:18])}
-                            data["Defects"].append(defect)
+            if line.startswith("SampleSize"):
+                match = re.search(r"SampleSize\s+1\s+(\d+)", line)
+                if match:
+                    data["SampleSize"] = int(match.group(1))
+
+            elif line.startswith("DiePitch"):
+                match = re.search(r"DiePitch\s+([0-9.e+-]+)\s+([0-9.e+-]+);", line)
+                if match:
+                    data["DiePitch"]["X"] = float(match.group(1))
+                    data["DiePitch"]["Y"] = float(match.group(2))
+
+            elif line.startswith("DieOrigin"):
+                match = re.search(r"DieOrigin\s+([0-9.e+-]+)\s+([0-9.e+-]+);", line)
+                if match:
+                    data["DieOrigin"]["X"] = float(match.group(1))
+                    data["DieOrigin"]["Y"] = float(match.group(2))
+
+            elif line.startswith("SampleCenterLocation"):
+                match = re.search(r"SampleCenterLocation\s+([0-9.e+-]+)\s+([0-9.e+-]+);", line)
+                if match:
+                    data["SampleCenterLocation"]["X"] = float(match.group(1))
+                    data["SampleCenterLocation"]["Y"] = float(match.group(2))
+
+            elif line.startswith("DefectList"):
+                dans_defect_list = True
+                continue
+
+            elif dans_defect_list:
+                # If in DefectList, filter by wafer if necessary
+                if wafer_id is not None and not reading_target_wafer:
+                    # In DefectList but not the right wafer, skip
+                    if line.startswith("EndOfFile") or line.startswith("}"):
+                        dans_defect_list = False
+                    continue
+                    
+                if re.match(r"^\d+\s", line):
+                    value = line.split()
+                    if len(value) >= 12:
+                        # Check if next line has exactly 2 columns
+                        if i + 1 < len(lines):
+                            next_line = lines[i + 1].strip()
+                            next_values = next_line.split()
+                            if len(next_values) == 2:
+                                # The real DEFECTID is the first element of next_values
+                                real_defect_id = int(next_values[0])
+                                defect = {f"val{i+1}": float(val) for i, val in enumerate(value[:10])}
+                                defect["defect_id"] = real_defect_id
+                                data["Defects"].append(defect)
+                elif line.startswith("EndOfFile") or line.startswith("}"):
+                    # End of DefectList
+                    dans_defect_list = False
 
         pitch_x = data["DiePitch"]["X"]
         pitch_y = data["DiePitch"]["Y"]
@@ -157,25 +224,41 @@ class PlotFrame(QWidget):
         Ycenter = data["SampleCenterLocation"]["Y"]
 
         corrected_positions = []
-
         for d in data["Defects"]:
-            val1 = d["val1"]
+            real_defect_id = d["defect_id"]  # Real DEFECTID (63, 64, 261, 262...)
             val2 = d["val2"]
             val3 = d["val3"]
             val4_scaled = d["val4"] * pitch_x - Xcenter
             val5_scaled = d["val5"] * pitch_y - Ycenter
+            defect_size = d["val9"]
 
             x_corr = round((val2 + val4_scaled) / 10000, 1)
             y_corr = round((val3 + val5_scaled) / 10000, 1)
 
             corrected_positions.append({
-                "defect_id": val1,
+                "defect_id": real_defect_id,
                 "X": x_corr,
-                "Y": y_corr
+                "Y": y_corr,
+                "defect_size": defect_size
             })
 
-         
-        self.coordinates = pd.DataFrame(corrected_positions, columns=["X", "Y"])
+        self.coordinates = pd.DataFrame(corrected_positions, columns=["defect_id", "X", "Y", "defect_size"])
+        
+        # Save mapping to CSV
+        import os
+        file_dir = os.path.dirname(filepath)
+        
+        # If wafer_id is specified (COMPLUS4T mode), save to wafer subfolder
+        if wafer_id is not None:
+            # COMPLUS4T mode: save to dirname/wafer_id/mapping.csv
+            csv_folder = os.path.join(file_dir, str(wafer_id))
+            os.makedirs(csv_folder, exist_ok=True)
+            csv_path = os.path.join(csv_folder, "mapping.csv")
+        else:
+            # Normal mode: save in same folder as .001 file
+            csv_path = os.path.join(file_dir, "mapping.csv")
+        
+        self.coordinates.to_csv(csv_path, index=False)
 
         return self.coordinates
 
@@ -187,43 +270,76 @@ class PlotFrame(QWidget):
         """
         if os.path.exists(csv_path):
             self.coordinates = pd.read_csv(csv_path)
-            print(f"Coordinates loaded: {self.coordinates.head()}")
         else:
-            print(f"CSV file not found: {csv_path}")
+            # CSV not found, will need to extract from KLARF file
+            pass
 
     def open_tiff(self):
         """Handle TIFF file opening and display."""
         self.selected_wafer = self.button_frame.get_selected_option()
         
         if not all([self.selected_wafer]):
-            print("Recipe and wafer selection required")
             self._reset_display()
             return
 
-
-        folder_path = os.path.join(self.button_frame.folder_var_changed(), 
-                                 str(self.selected_wafer))
+        # Check if COMPLUS4T mode is active
+        dirname = self.button_frame.folder_var_changed()
+        is_complus4t = self._check_complus4t_mode(dirname)
+        self.is_complus4t_mode = is_complus4t  # Store mode for later use
         
-        # Find the first .001 file in the selected folder
-        matching_files = glob.glob(os.path.join(folder_path, '*.001'))
-
-        # Sort the files to ensure consistent ordering
-        if matching_files:
-            recipe_path = matching_files[0]
+        if is_complus4t:
+            # COMPLUS4T mode: .001 and .tiff files in parent directory
+            folder_path = dirname
+            
+            # Find the .001 file with the selected wafer ID in parent directory
+            matching_files = glob.glob(os.path.join(dirname, '*.001'))
+            recipe_path = None
+            
+            for file_path in matching_files:
+                if self._is_wafer_in_klarf(file_path, self.selected_wafer):
+                    recipe_path = file_path
+                    break
+            
+            # Find the only .tiff file in the parent directory
+            tiff_files = glob.glob(os.path.join(dirname, '*.tiff'))
+            if not tiff_files:
+                tiff_files = glob.glob(os.path.join(dirname, '*.tif'))
+            
+            if tiff_files:
+                tiff_path = tiff_files[0]
+            else:
+                self._reset_display()
+                return
+            
+            # Extract positions for the specific wafer
+            self.coordinates = self.extract_positions(recipe_path, wafer_id=self.selected_wafer)
         else:
-            recipe_path = None  
-        
-        self.coordinates = self.extract_positions(recipe_path)     
-        
-        tiff_path = os.path.join(folder_path, "data.tif")
+            # Normal mode: subfolders
+            folder_path = os.path.join(dirname, str(self.selected_wafer))
+            
+            # Find the first .001 file in the selected folder
+            matching_files = glob.glob(os.path.join(folder_path, '*.001'))
 
-        if not os.path.isfile(tiff_path):
-            print(f"TIFF file not found in {folder_path}")
-            self._reset_display()
-            return
+            # Sort the files to ensure consistent ordering
+            if matching_files:
+                recipe_path = matching_files[0]
+            else:
+                recipe_path = None  
+            
+            tiff_path = os.path.join(folder_path, "data.tif")
+
+            if not os.path.isfile(tiff_path):
+                self._reset_display()
+                return
+            
+            # Extract all positions (normal mode)
+            self.coordinates = self.extract_positions(recipe_path)     
 
         self._load_tiff(tiff_path)
-        self._update_plot() 
+        self._update_plot()
+        
+        # Set reference to plot_frame in button_frame for slider updates
+        self.button_frame.plot_frame = self
 
         msg = QMessageBox()
         msg.setIcon(QMessageBox.Information)
@@ -232,6 +348,34 @@ class PlotFrame(QWidget):
         msg.setStyleSheet(MESSAGE_BOX_STYLE)
         msg.exec_()
 
+    def _check_complus4t_mode(self, dirname):
+        """Check if we are in COMPLUS4T mode (.001 files with COMPLUS4T in parent directory)."""
+        if not dirname or not os.path.exists(dirname):
+            return False
+        
+        # Check for .001 files with COMPLUS4T in the parent directory
+        matching_files = glob.glob(os.path.join(dirname, '*.001'))
+        for file_path in matching_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                    if 'COMPLUS4T' in content:
+                        return True
+            except Exception:
+                pass
+        
+        return False
+
+    def _is_wafer_in_klarf(self, file_path, wafer_id):
+        """Check if a specific wafer ID is in the KLARF file."""
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+                pattern = r'WaferID\s+"@' + str(wafer_id) + r'"'
+                return re.search(pattern, content) is not None
+        except Exception:
+            return False
+
     def _reset_display(self):
         """
         Resets the display by clearing the figure and reinitializing the subplot.
@@ -300,11 +444,32 @@ class PlotFrame(QWidget):
         ax.set_ylabel('Y (cm)', fontsize=20)
         
         if self.coordinates is not None:
-            x_coords = self.coordinates.iloc[:, 0]
-            y_coords = self.coordinates.iloc[:, 1]
+            # Get all coordinates
+            x_coords = self.coordinates['X']
+            y_coords = self.coordinates['Y']
+            defect_size = self.coordinates['defect_size']
+            
+            # Determine color based on mode
+            if self.is_complus4t_mode:
+                # Mode COMPLUS4T: color based on slider threshold
+                threshold = 0.0  # Default threshold
+                result = self.button_frame.get_selected_image()
+                if result is not None:
+                    threshold = result[0]  # Slider value in nm
+                
+                # Red if size >= threshold, blue otherwise
+                colors = ['red' if size >= threshold else 'blue' for size in defect_size]
+            else:
+                # Normal mode: color based on fixed threshold (10 nm)
+                colors = ['red' if size > 1.0e+01 else 'blue' for size in defect_size]
+            
+            ax.scatter(x_coords, y_coords, color=colors, marker='o',
+                       s=100, label='Positions')
 
-            # Calculate the maximum value for scaling
-            max_val = max(abs(x_coords).max(), abs(y_coords).max())
+            # Calculate the maximum value for scaling using ALL coordinates
+            x_coords_all = self.coordinates['X']
+            y_coords_all = self.coordinates['Y']
+            max_val = max(abs(x_coords_all).max(), abs(y_coords_all).max())
 
             if max_val <= 5:
                 radius = 5
@@ -318,9 +483,6 @@ class PlotFrame(QWidget):
                 radius = max_val  # fallback for > 15
 
             self.radius = radius
-
-            ax.scatter(x_coords, y_coords, color='blue', marker='o',
-                       s=100, label='Positions')
             
             # Set limits based on the radius
             ax.set_xlim(-radius - 1, radius + 1)
@@ -330,8 +492,13 @@ class PlotFrame(QWidget):
                                 fill=False, linewidth=0.5)
             ax.add_patch(circle)
             ax.set_aspect('equal')
+            
+            # Add grid
+            ax.grid(True, alpha=0.3, linestyle='-', linewidth=0.5)
+            ax.set_axisbelow(True)
         else:
-            print("No coordinates available to plot")
+            # No coordinates available
+            pass
         
 
         ax.figure.subplots_adjust(left=0.15, right=0.95, top=0.90, bottom=0.1)
@@ -348,7 +515,6 @@ class PlotFrame(QWidget):
         if result is not None:
             self.image_type, self_number_type = result
         else:
-            print("No image selected.")
             return
 
         if event.inaxes:
@@ -361,9 +527,7 @@ class PlotFrame(QWidget):
                                     (self.coordinates['Y'] - y_pos) ** 2)
                 closest_idx = distances.idxmin()
                 closest_pt = self.coordinates.iloc[closest_idx]
-                print(f"The closest point is: X = {closest_pt['X']}, "
-                      f"Y = {closest_pt['Y']}")
-
+                
                 # Replot with a red circle around the selected point
                 self.ax.clear()  # Clear the existing plot
                 self.plot_mapping_tpl(self.ax)
@@ -375,9 +539,20 @@ class PlotFrame(QWidget):
                 self.canvas.draw()
 
                 # Update the image based on the selected point
-                result = self.image_type + (closest_idx * self_number_type)
+                if self.is_complus4t_mode:
+                    # COMPLUS4T mode: use DEFECTID from KLARF file
+                    defect_id = int(closest_pt['defect_id'])
+                    # DEFECTID starts at 1, but Python indices start at 0
+                    result = defect_id - 1
+                else:
+                    # Normal mode: use DataFrame index (original behavior)
+                    result = self.image_type + (closest_idx * self_number_type)
+                
                 self.current_index = result
-                self.show_image()
+                
+                # Check if index is valid
+                if 0 <= self.current_index < len(self.image_list):
+                    self.show_image()
 
     def _load_tiff(self, tiff_path):
         """Load and prepare TIFF images for display.
@@ -403,5 +578,6 @@ class PlotFrame(QWidget):
             self.show_image()  # Display first image
             
         except Exception as e:
-            print(f"Error loading TIFF file: {e}")
+            # Error loading TIFF file
+            pass
             self._reset_display()