first commit from local

Author: yjg30737

.idea/.gitignore

@@ -0,0 +1,46 @@
+import numpy as np
+
+from PyQt5.QtCore import Qt, QRectF
+from PyQt5.QtGui import QPixmap, QImage
+from PyQt5.QtWidgets import QGraphicsScene, QGraphicsView
+
+
+class ImageView(QGraphicsView):
+    def __init__(self):
+        super().__init__()
+        self.__aspectRatioMode = Qt.KeepAspectRatio
+        self.__gradient_enabled = False
+        self.__initVal()
+
+    def __initVal(self):
+        self._scene = QGraphicsScene()
+        self._p = QPixmap()
+        self._item = ''
+
+    def displayPillowImage(self, image):
+        img_array = np.array(image)
+
+        # Convert NumPy array to QImage
+        if img_array.ndim == 3:
+            h, w, ch = img_array.shape
+            bytesPerLine = ch * w
+            qim = QImage(img_array.data, w, h, bytesPerLine, QImage.Format_RGB888)
+        else:
+            raise ValueError("Unsupported image dimension: {}".format(img_array.ndim))
+
+        pixmap = QPixmap.fromImage(qim)
+
+        self._scene.clear()
+
+        self._scene.addPixmap(pixmap)
+
+        self._scene.setSceneRect(QRectF(0, 0, pixmap.width(), pixmap.height()))
+        self.setScene(self._scene)
+        self.fitInView(self.sceneRect(), self.__aspectRatioMode)
+
+    def setAspectRatioMode(self, mode):
+        self.__aspectRatioMode = mode
+
+    def resizeEvent(self, e):
+        self.fitInView(self.sceneRect(), self.__aspectRatioMode)
+        return super().resizeEvent(e)

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,40 @@
+from PyQt5.QtWidgets import QLabel
+from PyQt5.QtCore import Qt, QTimer
+
+
+class LoadingLabel(QLabel):
+    def __init__(self):
+        super(LoadingLabel, self).__init__()
+        self.__initVal()
+        self.__initUi()
+
+    def __initVal(self):
+        self.__default_text = 'Wait'
+
+    def __initUi(self):
+        self.__timer = QTimer(self)
+        self.setText(self.__default_text)
+        self.setVisible(False)
+        self.setAlignment(Qt.AlignVCenter | Qt.AlignCenter)
+
+    def __timerInit(self):
+        self.__timer.timeout.connect(self.__ticking)
+        self.__timer.singleShot(0, self.__ticking)
+        self.__timer.start(500)
+
+    def __ticking(self):
+        dot = '.'
+        cur_text = self.text()
+        cnt = cur_text.count(dot)
+        if cnt % 3 == 0 and cnt != 0:
+            self.setText(self.__default_text + dot)
+        else:
+            self.setText(cur_text + dot)
+
+    def start(self):
+        self.setVisible(True)
+        self.__timerInit()
+
+    def stop(self):
+        self.setVisible(False)
+        self.__timer.stop()

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,115 @@
+import os, sys
+
+from imageView import ImageView
+from loadingLbl import LoadingLabel
+from script import ImagePredictor
+
+# Get the absolute path of the current script file
+script_path = os.path.abspath(__file__)
+
+# Get the root directory by going up one level from the script directory
+project_root = os.path.dirname(os.path.dirname(script_path))
+
+sys.path.insert(0, project_root)
+sys.path.insert(0, os.getcwd())  # Add the current directory as well
+
+from PyQt5.QtWidgets import QMainWindow, QPushButton, QApplication, QLineEdit, QVBoxLayout, QLabel, QWidget
+from PyQt5.QtCore import Qt, QCoreApplication, QThread, pyqtSignal
+from PyQt5.QtGui import QFont
+
+QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
+QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)  # HighDPI support
+
+QApplication.setFont(QFont('Arial', 12))
+
+
+class Thread(QThread):
+    generateFinished = pyqtSignal(str)
+
+    def __init__(self, image, pred: ImagePredictor):
+        super(Thread, self).__init__()
+        self.__image = image
+        self.__pred = pred
+
+    def run(self):
+        try:
+            self.generateFinished.emit(self.__pred.predict_image(self.__image))
+        except Exception as e:
+            raise Exception(e)
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super(MainWindow, self).__init__()
+        self.__initVal()
+        self.__initUi()
+
+    def __initVal(self):
+        model_path = 'result.pth'
+        self.__pred = ImagePredictor(model_path)
+
+    def __initUi(self):
+        self.setWindowTitle('PyTorch Image Classification')
+
+        self.__urlLineEdit = QLineEdit()
+        self.__urlLineEdit.setPlaceholderText('Input the URL...')
+        self.__urlLineEdit.textChanged.connect(self.__urlChanged)
+
+        self.__view = ImageView()
+
+        self.__runBtn = QPushButton('Run')
+        self.__runBtn.setEnabled(False)
+        self.__runBtn.clicked.connect(self.__run)
+
+        self.__waitLbl = LoadingLabel()
+        self.__waitLbl.setVisible(False)
+
+        self.__resultLbl = QLabel()
+        self.__resultLbl.setAlignment(Qt.AlignCenter)
+        self.__resultLbl.setVisible(False)
+
+        lay = QVBoxLayout()
+        lay.addWidget(self.__urlLineEdit)
+        lay.addWidget(self.__view)
+        lay.addWidget(self.__runBtn)
+        lay.addWidget(self.__waitLbl)
+        lay.addWidget(self.__resultLbl)
+
+        mainWidget = QWidget()
+        mainWidget.setLayout(lay)
+
+        self.setCentralWidget(mainWidget)
+
+    def __urlChanged(self, url):
+        self.__runBtn.setEnabled(url.strip() != '')
+
+    def __run(self):
+        image_url = self.__urlLineEdit.text()
+        image = self.__pred.get_image_from_url(image_url)
+        self.__view.displayPillowImage(image)
+        self.__t = Thread(image, self.__pred)
+        self.__t.started.connect(self.__started)
+        self.__t.generateFinished.connect(self.__generateFinished)
+        self.__t.finished.connect(self.__finished)
+        self.__t.start()
+
+    def __started(self):
+        self.__waitLbl.setVisible(True)
+        self.__runBtn.setEnabled(False)
+
+    def __generateFinished(self, result):
+        self.__resultLbl.setText(result)
+
+    def __finished(self):
+        self.__waitLbl.setVisible(False)
+        self.__resultLbl.setVisible(True)
+        self.__runBtn.setEnabled(True)
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    w = MainWindow()
+    w.show()
+    sys.exit(app.exec())

.idea/misc.xml

@@ -0,0 +1,90 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as transforms
+
+classes = ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
+
+# Define the model
+class Net(nn.Module):
+    def __init__(self, num_classes):
+        super(Net, self).__init__()
+        self.data_augmentation = nn.Sequential(
+            transforms.RandomHorizontalFlip(),
+            transforms.RandomRotation(10),
+            transforms.RandomAffine(degrees=0, translate=(0.1, 0.1))
+        )
+        self.model = nn.Sequential(
+            nn.Conv2d(3, 16, 3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(16, 32, 3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(32, 64, 3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Dropout(0.2),
+            nn.Flatten(),
+            nn.Linear(64 * 22 * 22, 128),
+            nn.ReLU(),
+            nn.Linear(128, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.data_augmentation(x)
+        return self.model(x)
+
+
+class ImagePredictor:
+    def __init__(self, model_path):
+        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        self.model = self.load_model(model_path)
+        self.transform = self.load_transform()
+
+    def load_model(self, model_path):
+        model = Net(len(classes)).to(self.device)
+        model.load_state_dict(torch.load(model_path))
+        return model
+
+    def load_transform(self):
+        img_height = 180
+        img_width = 180
+        transform = transforms.Compose([
+            transforms.Lambda(lambda img: img.convert('RGB')),
+            transforms.Resize((img_height, img_width)),  # 이미지 크기 조정
+            transforms.ToTensor()  # PIL 이미지를 텐서로 변환
+        ])
+        return transform
+
+    def get_image_from_url(self, image_url):
+        import requests
+        from PIL import Image
+        from io import BytesIO
+
+        response = requests.get(image_url)
+        image = Image.open(BytesIO(response.content))
+        return image
+
+    def predict_image(self, image):
+        image = self.transform(image)
+        image = image.unsqueeze(0)  # 배치 차원 추가
+        image = image.to(self.device)
+        #
+        output = self.model(image)
+        _, predicted = torch.max(output, 1)
+
+        prob = F.softmax(output, dim=1)[0] * 100
+
+        prob_res = round(prob[predicted[0]].item(), 2)
+
+        return f'<span style="color: blue">Predicted: {classes[predicted[0]]}</span><br/>' \
+               f'Percent: {prob_res}'
+
+# pred = ImagePredictor('result.pth')
+# image = pred.get_image_from_url('https://www.health.com/thmb/AADrlQdpWITCjFjKnfBnqWy5A8w=/2153x0/filters:no_upscale():max_bytes(150000):strip_icc()/Dandelion-d5aed7a95a6f4b16a3e954aa78694626.jpg')
+# print(pred.predict_image(image))
+# image = pred.get_image_from_url('https://ucarecdn.com/8b756a96-8495-4d00-9201-601d6b49c700/')
+# print(pred.predict_image(image))
+# image = pred.get_image_from_url('https://www.bolster.eu/media/images/5460_dbweb.jpg?1549350221')
+# print(pred.predict_image(image))