v2

app.py

@@ -16,6 +16,10 @@ from processing.classification_model import classify
 from processing.barsplots_rootcauses import check_classification
 from processing.cloud_access import auto_download
 
+from processing.processing_data import slice_data
+from processing.processing_data import create_recurrence_plot
+from processing.processing_data import classification
+
 sprint_data_folder = "Messungen"
 seafile_token = os.environ['SEAFILE_TOKEN']
 
@@ -99,60 +103,51 @@ def main():
 
             st.image("assets/slice.png")
 
-            auswahl = st.radio("Merkmal", ["Vorschub", "Schnitttiefe", "Werkzeugverschleiß"], horizontal=True, index=0)
-            #width = 500
+            # auswahl = st.radio("Merkmal", ["Vorschub", "Schnitttiefe", "Werkzeugverschleiß"], horizontal=True, index=0)
+            # #width = 500
         
 
-            if auswahl == "Vorschub":
-                st.image("assets/max_Vorschub.PNG")
-            elif auswahl == "Schnitttiefe":
-                st.image("assets/max_Schnitttiefe.PNG")
-            else:
-                st.image("assets/max_Verschleiß.PNG")
+            # if auswahl == "Vorschub":
+            #     st.image("assets/max_Vorschub.PNG")
+            # elif auswahl == "Schnitttiefe":
+            #     st.image("assets/max_Schnitttiefe.PNG")
+            # else:
+            #     st.image("assets/max_Verschleiß.PNG")
 
     with tab2:
 
         selected_file = st.selectbox("Oberflächenscan auswählen", sprint_csv_files, 0)
-        col1, col_blanc, col2= st.columns([0.6, 0.05, 0.35], gap="large")
+        col1, col_blanc, col2= st.columns([0.45, 0.1, 0.40], gap="large")
 
         with col1:
             try:
                 fig = surface_plot(selected_file)
-                fig.update_layout(height=600, width=800)
+                fig.update_layout(height=800, width=600)
                 st.plotly_chart(fig, theme="streamlit", use_container_width=False)
             except:
                 pass
+
         
         with col_blanc:
             st.write("")
         
         with col2:
-            st.markdown("<h2 style='text-align: center; color: black; font-family:Arial;font-size:2rem;'>Klassifizierung</h2>", unsafe_allow_html=True)
-            st.markdown("#")
-            
-            dummy, tolerance, z_data, fivetothirty = plot_timeseries(selected_file, 9)
-            data = fivetothirty["z"].values
-            mean = np.mean(data)
-            data = data - mean
+            st.markdown("<h2 style='text-align: center; color: black; font-family:Arial;font-size:2rem;'>Auswertung</h2>", unsafe_allow_html=True)
             
-            try:
-                data = torch.tensor(data, dtype=torch.float).to("cpu")
-                data = data.view(1,1,500)
-                prediction = classify(data)
-
-                fig_feed, fig_depth, fig_condition = check_classification(prediction[0])
-                st.pyplot(fig_feed)
-                st.pyplot(fig_depth)
-                st.pyplot(fig_condition) 
-            except Exception as e:
-                st.write(e)
+            sliced_data = slice_data(selected_file)
+            recurrence_plot = create_recurrence_plot(sliced_data)
+            classification_result = classification(recurrence_plot)
+            fig_feed, fig_depth, fig_wear = check_classification(classification_result)
+            st.pyplot(fig_feed)
+            st.pyplot(fig_depth)
+            st.pyplot(fig_wear)
 
 
 if __name__ == "__main__":
     main()
 
-    t1 = threading.Thread(target=auto_download, args=(seafile_token,))
-    t1.start()
+    #t1 = threading.Thread(target=auto_download, args=(seafile_token,))
+    #t1.start()
 
 
 

processing/{model_d2_v0.6.pt → _best_model_fold_3.pt}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f35b7eedb4f7e7a87010dd5e796ff88c589045ce6e1582bbe1de427b99e2336d
-size 139143916
+oid sha256:da9776ab0218a1da6f8b89383cafaa961732337624ffb08a18ea915bfe7c5d0b
+size 44808074

processing/model_d2_v0.7.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:431422f57a7b87f61e13e11304302a0f4aa3ab185990080acc8691c921645767
-size 139137029

processing/processing_data.py

@@ -0,0 +1,139 @@
+import pandas as pd
+import numpy as np
+import torch
+from torchvision import transforms, models
+from PIL import Image
+from torch import nn
+from pyts.image import RecurrencePlot
+
+
+def slice_data(csv):
+        
+    df = pd.read_csv(csv, sep=",", encoding="utf-16", header=None)
+    df.columns = ['x', 'y', 'z']
+
+    # slicing
+    df = df.iloc[:16000]
+    df = df[(df['y'] > -30) & (df['y'] < -5)] 
+    df = df[(df['x'] > -5.5) & (df['x'] < 5.5)]
+
+    # transform x, y, z
+    df["x"] = df["x"] +7.5      # in the raw data, X = 0 is in the middle of the workpiece-width. Shift X to the left by 7.5 mm to have X = 0 at the left edge of the workpiece.
+    df["y"] = df["y"] * (-1)    # flip the y-axis
+    df['z'] = df['z'] - (1.5)        # the radius of the tip of the measuring device is 1.5 mm and needs to be substracted from z
+
+    # These are the constant X values for the slicing, where the measuring probe actually moves along the y-axis:
+    x_values = [2.4, 3, 3.6, 4.2, 4.8, 5.4, 6, 6.6, 7.2, 7.8, 8.4, 9, 9.6, 10.2, 10.8, 11.4, 12, 12.6]
+    tol = 0.1
+    x_set = 5
+
+    x = x_values[x_set]
+
+    data = df[(df['x'] > x-tol) & (df['x'] < x+tol)]
+
+    # Delete column "x" if it exists
+    if "x" in data.columns:
+        data.drop(columns=["x"], inplace=True)
+
+    # Sort by y
+    data = data.sort_values(by=['y'])
+
+
+    # Normalize z values by subtracting the mean. Maybe try global normalization instead
+    z = data['z'].values
+    mean = np.mean(z)
+    data['z'] = data['z'] - mean
+    data['z'] = data['z'].apply(lambda x: round(x, 6))
+
+    data.reset_index(drop=True, inplace=True)
+
+    return data
+
+
+
+def create_recurrence_plot(sliced_data):
+
+    global_vmin = 0
+    global_vmax = 1
+
+    z = sliced_data['z'].values
+    # Normalize z values to the range [global_vmin, global_vmax] for RP transformation
+    z_normalized = (z - np.min(z)) / (np.max(z) - np.min(z))
+    z_normalized = z_normalized * (global_vmax - global_vmin) + global_vmin
+
+    # Create RP image
+    rp = RecurrencePlot(dimension=1, time_delay=1, threshold='point', percentage=20)
+    rp_image = rp.fit_transform(z_normalized.reshape(1, -1))[0]
+
+    # Convert the RP image to a PIL Image object
+    rp_image_pil = Image.fromarray((rp_image * 255).astype(np.uint8))
+
+    # Resize the image to 512*512 pixels
+    rp_image_resized = rp_image_pil.resize((512, 512), Image.LANCZOS)
+
+    # convert to grayscale
+    rp_image_resized = rp_image_resized.convert('L')
+
+    return rp_image_resized
+
+
+
+def classification(image):
+
+# Define transformations for images
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),  # Resize to match ResNet input size
+        transforms.ToTensor(),  # Convert PIL image to PyTorch tensor
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+
+    # Define the MultiOutputModel class as it was initially
+    class MultiOutputModel(nn.Module):
+        def __init__(self, base_model, num_classes_list):
+            super(MultiOutputModel, self).__init__()
+            num_features = base_model.fc.in_features
+            base_model.fc = nn.Identity()
+            self.base_model = base_model
+            self.fc_feed_rate = nn.Linear(num_features, num_classes_list[0])
+            self.fc_cutting_depth = nn.Linear(num_features, num_classes_list[1])
+            self.fc_tool_wear = nn.Linear(num_features, num_classes_list[2])
+
+        def forward(self, x):
+            x = self.base_model(x)
+            feed_rate_out = self.fc_feed_rate(x)
+            cutting_depth_out = self.fc_cutting_depth(x)
+            tool_wear_out = self.fc_tool_wear(x)
+            return tool_wear_out, feed_rate_out, cutting_depth_out
+
+    # Recreate the base model and MultiOutputModel
+    base_model = models.resnet18(weights='DEFAULT')
+    model = MultiOutputModel(base_model, [3, 3, 3])
+
+    # Load the model state dict
+    model_path = r'processing/_best_model_fold_3.pt'
+    model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))
+
+    # Set the model to evaluation model
+    model.eval()
+
+    # Check if GPU is available and move model to GPU
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model.to(device)
+
+    img = image.convert('RGB')
+    img = transform(img)
+    img = img.unsqueeze(0)  # Add batch dimension
+
+
+    # Move the tensor to the appropriate device (CPU in this case)
+    img_tensor = img.to(torch.device('cpu'))
+
+    with torch.no_grad():
+        tool_wear_out, feed_rate_out, cutting_depth_out = model(img_tensor)
+
+    # Step 4: Interpret the Results
+    predicted_feed = torch.argmax(feed_rate_out, dim=1).item()
+    predicted_depth = torch.argmax(cutting_depth_out, dim=1).item()
+    predicted_toolwear = torch.argmax(tool_wear_out, dim=1).item()
+
+    return predicted_feed, predicted_depth, predicted_toolwear